Iterate entry WS keys for headwords; add headword to search post-filter

- ComputeHeadwords: iterate CitationForm/LexemeForm keys instead of a
  passed-in vernacular WS list, so non-current WSs get headwords too
- Same change for FwDataMiniLcmApi.ComputeHeadword
- Remove GetVernacularWritingSystems() from MiniLcmRepository (no longer needed)
- Simplify Finalize overload signature (drop vernacularWritingSystems param)
- Add headword match to FilterInternal WHERE clause so entries with
  morph-token-decorated headwords aren't excluded by the post-filter
- Add TODO to Filtering.cs for the same pattern

https://claude.ai/code/session_01GFNCNDE5wHE2hGC7pQQp2f

Author: claude

backend/FwLite/FwDataMiniLcmBridge/Api/FwDataMiniLcmApi.cs

@@ -671,15 +671,19 @@ private Entry FromLexEntry(ILexEntry entry)
         }
     }
 
-    private MultiString ComputeHeadword(Entry result, IMoMorphType? lcmMorphType)
+    private static MultiString ComputeHeadword(Entry result, IMoMorphType? lcmMorphType)
     {
         var headword = new MultiString();
         var leading = lcmMorphType?.Prefix ?? "";
         var trailing = lcmMorphType?.Postfix ?? "";
 
-        foreach (var wsDef in WritingSystemContainer.CurrentVernacularWritingSystems)
+        // Iterate all WS keys that have data, not just "current" vernacular WSs,
+        // so we don't lose headwords for non-current or future writing systems.
+        var wsIds = result.CitationForm.Values.Keys
+            .Union(result.LexemeForm.Values.Keys);
+
+        foreach (var wsId in wsIds)
         {
-            WritingSystemId wsId = wsDef.Id;
             var citation = result.CitationForm[wsId];
             if (!string.IsNullOrEmpty(citation))
             {

backend/FwLite/LcmCrdt/Data/EntryQueryHelpers.cs

@@ -38,31 +38,36 @@ public static string HeadwordWithTokens(this Entry e, WritingSystemId ws, string
                 : Json.Value(e.CitationForm, ms => ms[ws])!.Trim();
 
     /// <summary>
-    /// Computes headwords for all vernacular writing systems, applying morph tokens when CitationForm is absent.
+    /// Computes headwords for all writing systems present in CitationForm or LexemeForm,
+    /// applying morph tokens when CitationForm is absent.
     /// Used for in-memory population of Entry.Headword after loading from DB.
     /// </summary>
     public static MultiString ComputeHeadwords(Entry entry,
-        IReadOnlyDictionary<MorphType, MorphTypeData> morphTypeDataLookup,
-        IEnumerable<WritingSystem> vernacularWritingSystems)
+        IReadOnlyDictionary<MorphType, MorphTypeData> morphTypeDataLookup)
     {
         var result = new MultiString();
         morphTypeDataLookup.TryGetValue(entry.MorphType, out var morphData);
 
-        foreach (var ws in vernacularWritingSystems)
+        // Iterate all WS keys that have data, not just "current" vernacular WSs,
+        // so we don't lose headwords for non-current or future writing systems.
+        var wsIds = entry.CitationForm.Values.Keys
+            .Union(entry.LexemeForm.Values.Keys);
+
+        foreach (var wsId in wsIds)
         {
-            var citation = entry.CitationForm[ws.WsId];
+            var citation = entry.CitationForm[wsId];
             if (!string.IsNullOrEmpty(citation))
             {
-                result[ws.WsId] = citation.Trim();
+                result[wsId] = citation.Trim();
                 continue;
             }
 
-            var lexeme = entry.LexemeForm[ws.WsId];
+            var lexeme = entry.LexemeForm[wsId];
             if (!string.IsNullOrEmpty(lexeme))
             {
                 var leading = morphData?.LeadingToken ?? "";
                 var trailing = morphData?.TrailingToken ?? "";
-                result[ws.WsId] = (leading + lexeme + trailing).Trim();
+                result[wsId] = (leading + lexeme + trailing).Trim();
             }
         }
 

backend/FwLite/LcmCrdt/Data/Filtering.cs

@@ -15,6 +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).
     public static Expression<Func<Entry, bool>> SearchFilter(string query)
     {
         return e => e.LexemeForm.SearchValue(query)

backend/FwLite/LcmCrdt/Data/MiniLcmRepository.cs

@@ -78,15 +78,6 @@ public void Dispose()
     private IReadOnlyDictionary<MorphType, MorphTypeData> _morphTypeDataLookup =
         new Dictionary<MorphType, MorphTypeData>();
 
-    private WritingSystem[]? _vernacularWritingSystems;
-
-    private async ValueTask<WritingSystem[]> GetVernacularWritingSystems()
-    {
-        return _vernacularWritingSystems ??= await WritingSystemsOrdered
-            .Where(ws => ws.Type == WritingSystemType.Vernacular)
-            .ToArrayAsync();
-    }
-
     public IQueryable<Publication> Publications => dbContext.Publications;
 
 
@@ -159,12 +150,11 @@ public async IAsyncEnumerable<Entry> GetEntries(
         queryable = options.ApplyPaging(queryable);
         var complexFormComparer = cultureProvider.GetCompareInfo(await GetWritingSystem(default, WritingSystemType.Vernacular))
             .AsComplexFormComparer();
-        var vernacularWss = await GetVernacularWritingSystems();
         var entries = AsyncExtensions.AsAsyncEnumerable(queryable);
         await EnsureConnectionOpen();//sometimes there can be a race condition where the collations arent setup
         await foreach (var entry in EfExtensions.SafeIterate(entries))
         {
-            entry.Finalize(complexFormComparer, _morphTypeDataLookup, vernacularWss);
+            entry.Finalize(complexFormComparer, _morphTypeDataLookup);
             yield return entry;
         }
     }
@@ -269,7 +259,7 @@ private ValueTask<IQueryable<Entry>> ApplySorting(IQueryable<Entry> queryable, Q
             var sortWs = await GetWritingSystem(WritingSystemId.Default, WritingSystemType.Vernacular);
             var complexFormComparer = cultureProvider.GetCompareInfo(sortWs)
                 .AsComplexFormComparer();
-            entry.Finalize(complexFormComparer, _morphTypeDataLookup, await GetVernacularWritingSystems());
+            entry.Finalize(complexFormComparer, _morphTypeDataLookup);
         }
 
         return entry;

backend/FwLite/LcmCrdt/FullTextSearch/EntrySearchService.cs

@@ -71,7 +71,12 @@ from entry in queryable.InnerJoin(r => r.Id == searchRecord.Id)
             where Sql.Ext.SQLite().Match(searchRecord, ftsString) &&
                 (entry.LexemeForm.SearchValue(query)
                 || entry.CitationForm.SearchValue(query)
-                || entry.Senses.Any(s => s.Gloss.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.
+                || SqlHelpers.ContainsIgnoreCaseAccents(entry.Headword(wsId), query))
             let headword = entry.Headword(wsId)
             let headwordMatches = SqlHelpers.ContainsIgnoreCaseAccents(headword, query)
             let headwordPrefixMatches = SqlHelpers.StartsWithIgnoreCaseAccents(headword, query)

backend/FwLite/LcmCrdt/QueryHelpers.cs

@@ -7,11 +7,10 @@ public static class QueryHelpers
 {
     public static void Finalize(this Entry entry,
         IComparer<ComplexFormComponent> complexFormComparer,
-        IReadOnlyDictionary<MorphType, MorphTypeData> morphTypeDataLookup,
-        WritingSystem[] vernacularWritingSystems)
+        IReadOnlyDictionary<MorphType, MorphTypeData> morphTypeDataLookup)
     {
         entry.Finalize(complexFormComparer);
-        entry.Headword = EntryQueryHelpers.ComputeHeadwords(entry, morphTypeDataLookup, vernacularWritingSystems);
+        entry.Headword = EntryQueryHelpers.ComputeHeadwords(entry, morphTypeDataLookup);
     }
 
     public static void Finalize(this Entry entry, IComparer<ComplexFormComponent> complexFormComparer)