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

backend/FwLite/FwLiteShared/TypeGen/ChangeTypesCodeGenerator.cs

@@ -0,0 +1,45 @@
+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);
+        // Mirrors Harmony's own discriminator logic, so the generated list stays in sync with the runtime $type:
+        // generic/shared changes (jsonPatch:, delete:, SetOrderChange:) define a custom static TypeName, while a
+        // dedicated change class (e.g. SetPartOfSpeechChange) has none and serializes under its CLR type name.
+        // The fallback to changeType.Name is therefore intentional, not a silent mismatch.
+        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

@@ -177,6 +177,7 @@ private static void ConfigureFwLiteSharedTypes(ConfigurationBuilder builder)
             typeof(FwLiteConfig),
             typeof(HistoryLineItem),
             typeof(ProjectActivity),
+            typeof(ActivityChangeInfo),
             typeof(ActivityAuthor),
             typeof(ActivityChangeType),
             typeof(ActivityQuery),
@@ -190,6 +191,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/HistoryService.cs

@@ -36,6 +36,14 @@ public static class ActivityFilterKeys
     public const string AuthorNamePrefix = "name:";
 }
 
+/// <summary>
+/// Resolved display info for one change, so the frontend can name what the change is about.
+/// <paramref name="Subject"/> is the entity the change is on (entry headword, "headword › gloss" for a sense, or a vocab object's name);
+/// <paramref name="Target"/> is a referenced item the change names only by id (e.g. the part of speech assigned, the semantic domain removed).
+/// Both are null when unresolved — the frontend falls back to a type label.
+/// </summary>
+public record ActivityChangeInfo(string? Subject, Guid? RootEntryId, string? Target = null);
+
 public record ProjectActivity(
     Guid CommitId,
     DateTimeOffset Timestamp,
@@ -44,20 +52,23 @@ public record ProjectActivity(
 {
     public string ChangeName => HistoryService.ChangesNameHelper(Changes);
     public string[] ChangeTypes { get; } = Changes.Select(c => HistoryService.GetChangeTypeKey(c.Change)).Distinct().ToArray();
+    /// <summary>Resolved display info per change, parallel to <see cref="Changes"/> by index. Set during enrichment.</summary>
+    public IReadOnlyList<ActivityChangeInfo> ChangeInfo { get; set; } = [];
 }
 
 public record ChangeContext(
     Guid CommitId,
     int ChangeIndex,
     string ChangeName,
     IObjectWithId? Snapshot,
+    IObjectWithId? PreviousSnapshot,
     ICollection<Entry> AffectedEntries)
 {
-    public ChangeContext(ChangeEntity<IChange> change, IObjectWithId? snapshot, ICollection<Entry> affectedEntries)
-        : this(change.CommitId, change.Index, HistoryService.ChangeNameHelper(change.Change), snapshot, affectedEntries)
+    public ChangeContext(ChangeEntity<IChange> change, IObjectWithId? snapshot, IObjectWithId? previousSnapshot, ICollection<Entry> affectedEntries)
+        : this(change.CommitId, change.Index, HistoryService.ChangeNameHelper(change.Change), snapshot, previousSnapshot, affectedEntries)
     {
     }
-    public string EntityType => Snapshot?.GetType().Name ?? "Unknown";
+    public string EntityType => (Snapshot ?? PreviousSnapshot)?.GetType().Name ?? "Unknown";
 }
 
 public record HistoryLineItem(
@@ -143,7 +154,15 @@ from commit in commits.Skip(skip).Take(take)
                 NormalizeTimestamp(commit.HybridDateTime.DateTime),
                 commit.ChangeEntities.ToList(),
                 commit.Metadata);
+        // Materialize the whole page before resolving: ActivityChangeInfoResolver batch-loads labels across all
+        // changes in the page at once, so this enumerates the page rather than streaming row-by-row.
+        var activities = new List<ProjectActivity>();
         await foreach (var projectActivity in queryable.ToLinqToDB().AsAsyncEnumerable())
+        {
+            activities.Add(projectActivity);
+        }
+        await ActivityChangeInfoResolver.ResolveAsync(dbContext, activities);
+        foreach (var projectActivity in activities)
         {
             yield return projectActivity;
         }
@@ -301,21 +320,41 @@ public async Task<ChangeContext> LoadChangeContext(Guid commitId, int changeInde
 
         // Use safe cast - some entity types like RemoteResource don't implement IObjectWithId
         var snapshot = await dataModel.GetAtCommit<object>(commitId, change.EntityId) as IObjectWithId;
+        var previousSnapshot = await LoadPreviousSnapshot(crdtDbContext, commitId, change.EntityId);
+
+        await ResolveSensePartOfSpeech(snapshot);
+        await ResolveSensePartOfSpeech(previousSnapshot);
+
+        var affectedEntries = await GetAffectedEntryIds(change)
+            .Select(async (Guid entryId, CancellationToken _) => await GetCurrentOrLatestEntry(entryId))
+            .ToArrayAsync();
+
+        return new ChangeContext(change, snapshot, previousSnapshot, affectedEntries);
+    }
 
+    /// <summary>The entity's state just before <paramref name="commitId"/>, i.e. the snapshot at the most recent
+    /// commit that affected it before this one. Null if this commit created the entity.</summary>
+    private async Task<IObjectWithId?> LoadPreviousSnapshot(ICrdtDbContext dbContext, Guid commitId, Guid entityId)
+    {
+        var affectingCommitIds = await dbContext.Commits
+            .Where(c => c.ChangeEntities.Any(ce => ce.EntityId == entityId))
+            .DefaultOrderDescending()
+            .Select(c => c.Id)
+            .ToListAsyncLinqToDB();
+        var index = affectingCommitIds.IndexOf(commitId);
+        if (index < 0 || index + 1 >= affectingCommitIds.Count) return null;
+        return await dataModel.GetAtCommit<object>(affectingCommitIds[index + 1], entityId) as IObjectWithId;
+    }
+
+    // Older sense snapshots didn't store the part-of-speech object, only its id; resolve it so previews can show a label.
+    private async Task ResolveSensePartOfSpeech(IObjectWithId? snapshot)
+    {
         if (snapshot is Sense sense && sense.PartOfSpeechId != sense.PartOfSpeech?.Id)
         {
-            // previously we didn't update the part of speech object on sense snapshots
-            // we do now, so we patch old snapshots
             sense.PartOfSpeech = sense.PartOfSpeechId.HasValue
                 ? await dataModel.GetLatest<PartOfSpeech>(sense.PartOfSpeechId.Value)
                 : null;
         }
-
-        var affectedEntries = await GetAffectedEntryIds(change)
-            .Select(async (Guid entryId, CancellationToken _) => await GetCurrentOrLatestEntry(entryId))
-            .ToArrayAsync();
-
-        return new ChangeContext(change, snapshot, affectedEntries);
     }
 
     private async Task<Entry> GetCurrentOrLatestEntry(Guid entryId)

frontend/viewer/package.json

@@ -110,6 +110,7 @@
     "@lingui/core": "^5.6.1",
     "@microsoft/dotnet-js-interop": "^10.0.0",
     "@microsoft/signalr": "^10.0.0",
+    "@sanity/diff-match-patch": "^3.2.0",
     "fast-json-patch": "^3.1.1",
     "jsdom": "^26.1.0",
     "just-throttle": "^4.2.0",