live: collapse capture to a single image column, drop the side map

The before/after naming was cosmetic — the matcher only consumes the
union of (col, value) pairs, so one __typegres_live_image column serves
the mutation RETURNING and the update pre-select alike. imageReturning
takes just the table name; RETURNING_SIDE is gone; the strip/push loop
unifies into one pushImage helper.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ryanrasti

src/live/sqlite/capture.ts

@@ -31,8 +31,10 @@ import { Text } from "../../types/sqlite";
 // extractor emits, so the bus's string matching lines up. Keep the two
 // aligned (see ../canonical.ts).
 
-export const T_LIVE_BEFORE = "__typegres_live_before";
-export const T_LIVE_AFTER = "__typegres_live_after";
+// One column name serves every image: the matcher only consumes the
+// union of (col, value) pairs, so which state a JSON image snapshots
+// (before vs after) never needs to be distinguishable downstream.
+const T_LIVE_IMAGE = "__typegres_live_image";
 
 // `json_object('col', <canonical text of ref>, ...)` over every column
 // field of the row instance. SqlValue is the shared base of the sqlite
@@ -44,16 +46,15 @@ const buildImageJson = (tableInstance: { [c: string]: unknown }): Sql => {
   return sql`json_object(${sql.join(args)})`;
 };
 
-// returningMerge callback adding `__typegres_live_<side>` to the mutation's
+// returningMerge callback adding the image column to the mutation's
 // RETURNING. executeMutationWithCapture strips the column from result rows
 // before they reach deserializeRows (which throws on keys missing from the
 // row type).
 const imageReturning =
-  (tableName: string, side: "before" | "after") =>
+  (tableName: string) =>
   (ns: object): RowType => {
     const tableInstance = (ns as { [k: string]: object })[tableName] as { [c: string]: unknown };
-    const key = side === "before" ? T_LIVE_BEFORE : T_LIVE_AFTER;
-    return { [key]: Text.from(buildImageJson(tableInstance)) };
+    return { [T_LIVE_IMAGE]: Text.from(buildImageJson(tableInstance)) };
   };
 
 // The UPDATE before-image: select the image of every row the UPDATE's
@@ -82,7 +83,7 @@ const buildUpdatePreImageSelect = (builder: UpdateBuilder<any, any, any>): Sql =
   const whereClause = where ? where.toSql() : sql`TRUE`;
   return sql.withScope(
     [alias],
-    sql`SELECT ${buildImageJson(instance as { [c: string]: unknown })} AS ${new Ident(T_LIVE_BEFORE)} FROM ${database.scopedIdent(builder.tableName)} AS ${alias} WHERE ${whereClause}`,
+    sql`SELECT ${buildImageJson(instance as { [c: string]: unknown })} AS ${new Ident(T_LIVE_IMAGE)} FROM ${database.scopedIdent(builder.tableName)} AS ${alias} WHERE ${whereClause}`,
   );
 };
 
@@ -92,13 +93,6 @@ export type MutationBuilder =
   | UpdateBuilder<any, any, any>
   | DeleteBuilder<any, any, any>;
 
-// Which image the mutation's own RETURNING can carry.
-const RETURNING_SIDE: { [K in MutationOp]: "before" | "after" } = {
-  insert: "after",
-  delete: "before",
-  update: "after",
-};
-
 // A mutation's change events: (col, canonical-text value) pairs from the
 // before/after images, unstamped — the caller assigns xids when it pushes
 // them into the bus.
@@ -126,24 +120,24 @@ export const executeMutationWithCapture = (
   const table = builder.tableName;
   // returningMerge has the same shape on all three builders; pick one
   // overload rather than writing a generic structural type.
-  const merged = (builder as InsertBuilder<any, any, any>).returningMerge(
-    imageReturning(table, RETURNING_SIDE[op]),
-  );
+  const merged = (builder as InsertBuilder<any, any, any>).returningMerge(imageReturning(table));
   const compiled: CompiledSql = compile(merged, { database });
   const preCompiled =
     op === "update"
       ? compile(buildUpdatePreImageSelect(builder as UpdateBuilder<any, any, any>), { database })
       : undefined;
 
   const events: CapturedEvent[] = [];
+  const pushImage = (image: string | null | undefined) =>
+    events.push({ table, pairs: parseEventPairs(image ?? null, null) });
   const preRows = preCompiled ? executeSync(preCompiled).rows : [];
   for (const row of preRows) {
-    events.push({ table, pairs: parseEventPairs(row[T_LIVE_BEFORE] ?? null, null) });
+    pushImage(row[T_LIVE_IMAGE]);
   }
   const result = executeSync(compiled);
   const rows = result.rows.map((row) => {
-    const { [T_LIVE_BEFORE]: before, [T_LIVE_AFTER]: after, ...rest } = row;
-    events.push({ table, pairs: parseEventPairs(before ?? null, after ?? null) });
+    const { [T_LIVE_IMAGE]: image, ...rest } = row;
+    pushImage(image);
     return rest;
   });
   return { rows, events };