Rework the activity view: readable summaries and a before/after diff

backend/FwLite/FwLiteShared/TypeGen/ChangeTypesCodeGenerator.cs

@@ -0,0 +1,41 @@
+using System.Reflection;
+using LcmCrdt;
+using Reinforced.Typings;
+using Reinforced.Typings.Ast;
+using Reinforced.Typings.Generators;
+
+namespace FwLiteShared.TypeGen;
+
+/// <summary>
+/// Emits a `ChangeType` string-literal union and a `knownChangeTypes` array built from the registered CRDT
+/// change types (<see cref="LcmCrdtKernel.AllChangeTypes"/>) and each type's <c>IPolyType.TypeName</c>
+/// (the serialized <c>$type</c> discriminator). Attached to the <c>ChangeTypes</c> marker; suppresses the
+/// marker's own output.
+/// </summary>
+public class ChangeTypesCodeGenerator : ClassCodeGenerator
+{
+    public override RtClass GenerateNode(Type element, RtClass result, TypeResolver resolver)
+    {
+        var typeNames = LcmCrdtKernel.AllChangeTypes()
+            .Select(GetChangeTypeName)
+            .Distinct()
+            .OrderBy(name => name, StringComparer.Ordinal)
+            .ToArray();
+
+        var union = string.Concat(typeNames.Select(name => $"\n  | '{name}'"));
+        var array = string.Concat(typeNames.Select(name => $"\n  '{name}',"));
+
+        Context.Location.CurrentNamespace.CompilationUnits.Add(new RtRaw(
+            $"export type ChangeType ={union};\n\nexport const knownChangeTypes = [{array}\n] as const satisfies readonly ChangeType[];\n"));
+
+        // Suppress the marker class; only the raw union/array above is emitted.
+        return null!;
+    }
+
+    private static string GetChangeTypeName(Type changeType)
+    {
+        var typeNameProperty = changeType.GetProperty("TypeName",
+            BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
+        return typeNameProperty?.GetValue(null) as string ?? changeType.Name;
+    }
+}

backend/FwLite/FwLiteShared/TypeGen/ChangeTypesMarker.cs

@@ -0,0 +1,10 @@
+// Namespace is LcmCrdt (not FwLiteShared.TypeGen) on purpose: Reinforced.Typings derives the generated
+// file's path from the type's namespace, so this keeps the output at generated-types/LcmCrdt/ChangeTypes.ts.
+namespace LcmCrdt;
+
+/// <summary>
+/// Marker type only — no members. Reinforced.Typings (via <c>ChangeTypesCodeGenerator</c>) emits the
+/// <c>ChangeType</c> string-literal union and <c>knownChangeTypes</c> array into ChangeTypes.ts from the
+/// registered change types, so the frontend has a generated, exhaustive list of change <c>$type</c> values.
+/// </summary>
+internal sealed class ChangeTypes;

backend/FwLite/FwLiteShared/TypeGen/ReinforcedFwLiteTypingConfig.cs

@@ -175,6 +175,7 @@ private static void ConfigureFwLiteSharedTypes(ConfigurationBuilder builder)
             typeof(FwLiteConfig),
             typeof(HistoryLineItem),
             typeof(ProjectActivity),
+            typeof(ActivityChangeInfo),
             typeof(ActivityAuthor),
             typeof(ActivityChangeType),
             typeof(ActivityQuery),
@@ -188,6 +189,8 @@ private static void ConfigureFwLiteSharedTypes(ConfigurationBuilder builder)
             typeof(AvailableUpdate),
         ], exportBuilder => exportBuilder.WithPublicProperties());
 
+        builder.ExportAsClass<ChangeTypes>().WithCodeGenerator<ChangeTypesCodeGenerator>();
+
         builder.ExportAsEnum<ActivitySort>().UseString();
         builder.ExportAsEnum<FwEventType>().UseString();
         builder.ExportAsEnum<LogLevel>().UseString(false);

backend/FwLite/LcmCrdt.Tests/HistoryServiceActivityTests.cs

@@ -153,6 +153,7 @@ public async Task ProjectActivity_ChangeTypeKeys_FiltersMultipleTypes()
 
         var activities = await Service.ProjectActivity(0, 100, new ActivityQuery(ChangeTypeKeys: [nameof(CreateEntryChange), nameof(CreatePublicationChange)])).ToArrayAsync();
 
+        activities.Should().HaveCountGreaterThanOrEqualTo(2); // the entry + publication commits, so the filter can't pass vacuously on an empty result
         activities.Should().OnlyContain(a => a.ChangeTypes.Any(t => t == nameof(CreateEntryChange) || t == nameof(CreatePublicationChange)));
         activities.Should().NotContain(a => a.ChangeTypes.Contains(nameof(CreatePartOfSpeechChange)));
     }
@@ -167,6 +168,133 @@ public async Task ProjectActivity_IncludesChangeTypes()
         activity.ChangeTypes.Should().Contain("CreateEntryChange");
     }
 
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_AddsHomographSubscriptToSubject_OnlyWhenAssigned()
+    {
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry
+        {
+            Id = Guid.NewGuid(),
+            LexemeForm = new MultiString { ["en"] = "plain" }
+        }), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry
+        {
+            Id = Guid.NewGuid(),
+            LexemeForm = new MultiString { ["en"] = "homograph" },
+            HomographNumber = 2
+        }), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1 && a.ChangeInfo[0].Subject == "plain");
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1 && a.ChangeInfo[0].Subject == "homograph₂");
+    }
+
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_SkipsAudioAndUsesAnotherWritingSystem()
+    {
+        // The headword lives only in "seh"; the alphabetically-first writing system is audio, which Entry.Headword()
+        // would surface (or report "(Unknown)") — the activity headword skips audio and falls through to a real value.
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry
+        {
+            Id = Guid.NewGuid(),
+            LexemeForm = new MultiString
+            {
+                ["de-Zxxx-x-audio"] = "recording.wav",
+                ["seh"] = "nyumba"
+            }
+        }), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1 && a.ChangeInfo[0].Subject == "nyumba");
+    }
+
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_AppliesMorphTypeMarkers()
+    {
+        // Suffix morph types carry a leading "-" marker (seeded as a canonical morph type on project setup).
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry
+        {
+            Id = Guid.NewGuid(),
+            LexemeForm = new MultiString { ["en"] = "ness" },
+            MorphType = MorphTypeKind.Suffix
+        }), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1 && a.ChangeInfo[0].Subject == "-ness");
+    }
+
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_EmptyEntryHasNullSubject()
+    {
+        var entryId = Guid.NewGuid();
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry { Id = entryId }),
+            new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        // No displayable headword: the subject is null (the frontend renders its placeholder, never "(Unknown)"),
+        // but the change still resolves to its root entry.
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1
+            && a.ChangeInfo[0].RootEntryId == entryId
+            && a.ChangeInfo[0].Subject == null);
+    }
+
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_Reorder_NamesParentEntryAndMovedSense()
+    {
+        var entryId = Guid.NewGuid();
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry
+        {
+            Id = entryId,
+            LexemeForm = new MultiString { ["en"] = "run" }
+        }), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+        var senseId = Guid.NewGuid();
+        await DataModel.AddChange(ClientId, new CreateSenseChange(new Sense
+        {
+            Id = senseId,
+            Gloss = new MultiString { ["en"] = "to run" }
+        }, entryId), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+        await DataModel.AddChange(ClientId, new SetOrderChange<Sense>(senseId, 2.0), new CommitMetadata { AuthorName = "A", AuthorId = "a" });
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        // The reorder names the parent entry as the subject and the moved sense's gloss as the target.
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1 && a.ChangeInfo[0].Subject == "run" && a.ChangeInfo[0].Target == "to run");
+    }
+
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_NamesAVocabSubject()
+    {
+        var meta = new CommitMetadata { AuthorName = "A", AuthorId = "a" };
+        await DataModel.AddChange(ClientId, new CreatePartOfSpeechChange(Guid.NewGuid(), new MultiString { ["en"] = "Verb" }), meta);
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1 && a.ChangeInfo[0].Subject == "Verb");
+    }
+
+    [Fact]
+    public async Task ProjectActivity_ChangeInfo_NamesTheReferencedPartOfSpeech()
+    {
+        var meta = new CommitMetadata { AuthorName = "A", AuthorId = "a" };
+        var posId = Guid.NewGuid();
+        await DataModel.AddChange(ClientId, new CreatePartOfSpeechChange(posId, new MultiString { ["en"] = "Noun" }), meta);
+        var entryId = Guid.NewGuid();
+        await DataModel.AddChange(ClientId, new CreateEntryChange(new Entry { Id = entryId, LexemeForm = new MultiString { ["en"] = "run" } }), meta);
+        var senseId = Guid.NewGuid();
+        await DataModel.AddChange(ClientId, new CreateSenseChange(new Sense { Id = senseId, Gloss = new MultiString { ["en"] = "to run" } }, entryId), meta);
+        await DataModel.AddChange(ClientId, new SetPartOfSpeechChange(senseId, posId), meta);
+
+        var activities = await Service.ProjectActivity(0, 100, new ActivityQuery()).ToArrayAsync();
+
+        // The set-part-of-speech change names the sense as its subject and the assigned part of speech as its target.
+        activities.Should().Contain(a => a.ChangeInfo.Count == 1
+            && a.ChangeInfo[0].Subject == "run › to run"
+            && a.ChangeInfo[0].Target == "Noun");
+    }
+
     private async Task<Commit> AddEntryCommit(CommitMetadata metadata, string? headword = null)
     {
         var entry = headword is null