Single Finalize method; add commented-out morph token SQL expressions

- Merge Entry Finalize overloads into one that always requires
  morphTypeDataLookup — an entry can't be finalized without it
- Add commented-out HeadwordSearchValue expression and MorphTypeData
  JOIN patterns showing exactly how morph tokens will work in SQL
  once MorphTypeData becomes a CRDT entity
- Update TODOs in Filtering.cs and EntrySearchService.cs to reference
  the new HeadwordSearchValue pattern (all WSs, not per-wsId)

https://claude.ai/code/session_01GFNCNDE5wHE2hGC7pQQp2f

Author: claude

backend/FwLite/LcmCrdt/Data/EntryQueryHelpers.cs

@@ -37,6 +37,47 @@ public static string HeadwordWithTokens(this Entry e, WritingSystemId ws, string
                     : ((leading ?? "") + Json.Value(e.LexemeForm, ms => ms[ws]) + (trailing ?? "")).Trim()
                 : Json.Value(e.CitationForm, ms => ms[ws])!.Trim();
 
+    // === Morph-token-aware headword expressions (ready for when MorphTypeData is a CRDT entity) ===
+    //
+    // Once MorphTypeData is in the DB, use these in place of the token-free versions above.
+    //
+    // Usage in queries (e.g. EntrySearchService.FilterInternal, Filtering.cs):
+    //
+    //   var morphTypes = dbContext.GetTable<MorphTypeData>();
+    //
+    //   from entry in entries
+    //   from morphData in morphTypes.LeftJoin(m => (int)m.MorphType == (int)entry.MorphType)
+    //   let headword = entry.HeadwordWithTokens(wsId, morphData.LeadingToken, morphData.TrailingToken)
+    //   ...
+    //
+    // For searching headwords (with tokens) across ALL writing systems:
+    //
+    //   [ExpressionMethod(nameof(HeadwordSearchValueExpression))]
+    //   public static bool HeadwordSearchValue(Entry e, string? leading, string? trailing, string query)
+    //   {
+    //       return e.CitationForm.SearchValue(query)
+    //           || e.LexemeForm.Values.Any(kvp =>
+    //               SqlHelpers.ContainsIgnoreCaseAccents((leading ?? "") + kvp.Value + (trailing ?? ""), query));
+    //   }
+    //
+    //   private static Expression<Func<Entry, string?, string?, string, bool>> HeadwordSearchValueExpression() =>
+    //       (e, leading, trailing, query) =>
+    //           Json.QueryValues(e.CitationForm).Any(v => SqlHelpers.ContainsIgnoreCaseAccents(v, query))
+    //           || Json.QueryValues(e.LexemeForm).Any(v =>
+    //               SqlHelpers.ContainsIgnoreCaseAccents((leading ?? "") + v + (trailing ?? ""), query));
+    //
+    // Then in queries:
+    //
+    //   from morphData in morphTypes.LeftJoin(m => (int)m.MorphType == (int)entry.MorphType)
+    //   where entry.HeadwordSearchValue(morphData.LeadingToken, morphData.TrailingToken, query)
+    //       || entry.Senses.Any(s => s.Gloss.SearchValue(query))
+    //
+    // And for the FTS table (ToEntrySearchRecord), join MorphTypeData to get tokens:
+    //
+    //   from entry in entries
+    //   from morphData in morphTypes.LeftJoin(m => (int)m.MorphType == (int)entry.MorphType)
+    //   let headword = entry.HeadwordWithTokens(ws.WsId, morphData.LeadingToken, morphData.TrailingToken)
+
     /// <summary>
     /// Computes headwords for all writing systems present in CitationForm or LexemeForm,
     /// applying morph tokens when CitationForm is absent.

backend/FwLite/LcmCrdt/Data/Filtering.cs

@@ -15,8 +15,8 @@ public static IQueryable<Entry> WhereExemplar(
         return query.Where(e => e.Headword(ws).StartsWith(exemplar));
     }
 
-    // TODO: When morph tokens are added, this should also check headword with tokens.
-    // See EntrySearchService.FilterInternal for the pattern (needs wsId parameter).
+    // TODO: When morph tokens are added, also check headword with tokens across all WSs.
+    // Use the pattern from EntryQueryHelpers.HeadwordSearchValue (currently commented out).
     public static Expression<Func<Entry, bool>> SearchFilter(string query)
     {
         return e => e.LexemeForm.SearchValue(query)

backend/FwLite/LcmCrdt/FullTextSearch/EntrySearchService.cs

@@ -72,10 +72,9 @@ where Sql.Ext.SQLite().Match(searchRecord, ftsString) &&
                 (entry.LexemeForm.SearchValue(query)
                 || entry.CitationForm.SearchValue(query)
                 || entry.Senses.Any(s => s.Gloss.SearchValue(query))
-                // Headword includes morph tokens (e.g. "-" prefix for suffixes) that aren't in
-                // LexemeForm/CitationForm. Without this, FTS matches on token-decorated headwords
-                // would be excluded by the post-filter. Currently only checks the active WS;
-                // when MorphTypeData becomes a CRDT entity, Headword() will include real tokens.
+                // TODO: When MorphTypeData is a CRDT entity, replace the line below with
+                // HeadwordSearchValue to match morph-token-decorated headwords across ALL WSs.
+                // See EntryQueryHelpers for the commented-out HeadwordSearchValue expression.
                 || SqlHelpers.ContainsIgnoreCaseAccents(entry.Headword(wsId), query))
             let headword = entry.Headword(wsId)
             let headwordMatches = SqlHelpers.ContainsIgnoreCaseAccents(headword, query)
@@ -266,7 +265,8 @@ private static EntrySearchRecord ToEntrySearchRecord(Entry entry, WritingSystem[
     {
         // Include headwords for ALL vernacular writing systems (space-separated), matching how
         // LexemeForm and CitationForm already work. This ensures FTS matches across all WS.
-        // TODO: Include morph tokens once MorphTypeData is available as a CRDT entity.
+        // TODO: Include morph tokens once MorphTypeData is a CRDT entity.
+        // See EntryQueryHelpers for the commented-out JOIN pattern.
         var headword = string.Join(" ",
             writingSystems.Where(ws => ws.Type == WritingSystemType.Vernacular)
                 .Select(ws => entry.Headword(ws.WsId))

backend/FwLite/LcmCrdt/QueryHelpers.cs

@@ -8,12 +8,6 @@ public static class QueryHelpers
     public static void Finalize(this Entry entry,
         IComparer<ComplexFormComponent> complexFormComparer,
         IReadOnlyDictionary<MorphType, MorphTypeData> morphTypeDataLookup)
-    {
-        entry.Finalize(complexFormComparer);
-        entry.Headword = EntryQueryHelpers.ComputeHeadwords(entry, morphTypeDataLookup);
-    }
-
-    public static void Finalize(this Entry entry, IComparer<ComplexFormComponent> complexFormComparer)
     {
         entry.Senses.ApplySortOrder();
         entry.Components.ApplySortOrder();
@@ -22,6 +16,7 @@ public static void Finalize(this Entry entry, IComparer<ComplexFormComponent> co
         {
             sense.Finalize();
         }
+        entry.Headword = EntryQueryHelpers.ComputeHeadwords(entry, morphTypeDataLookup);
     }
 
     public static void Finalize(this Sense sense)