@cosmicdrift/kumiko-framework 0.122.0 → 0.122.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.122.0",
+  "version": "0.122.2",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -189,7 +189,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.122.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.122.2",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/db/__tests__/rebuild-marker.test.ts

@@ -28,14 +28,16 @@ function tmpDir(): string {
 }
 
 describe("rebuildTablesFromDiff", () => {
-  test("managed: new + changed tables included, dropped excluded, sorted + unique", () => {
+  test("managed: new table rebuilt, additive-only change NOT rebuilt, dropped excluded", () => {
+    // read_a: nur eine nullable Spalte dazu → in-place ALTER, kein Rebuild.
+    // read_b: neue Tabelle → Rebuild. read_c gedroppt → nie im Marker.
     const prev = snapshotFromMetas([meta("read_a"), meta("read_c")]);
     const next = snapshotFromMetas([
       meta("read_a", { name: "title", pgType: "text", notNull: false }),
       meta("read_b"),
     ]);
     const diff = diffSnapshots(prev, next);
-    expect(rebuildTablesFromDiff(diff)).toEqual(["read_a", "read_b"]);
+    expect(rebuildTablesFromDiff(diff)).toEqual(["read_b"]);
   });
 
   test("no schema change → empty", () => {
@@ -51,11 +53,19 @@ describe("rebuildTablesFromDiff", () => {
     expect(rebuildTablesFromDiff(diffSnapshots(prev, next))).toEqual([]);
   });
 
-  test("managed new nullable column → rebuild (Backfill aus Events nötig)", () => {
+  test("managed new NULLABLE column → NO rebuild (in-place ADD COLUMN reicht; Rebuild würde die Spalte wischen, #835)", () => {
     const prev = snapshotFromMetas([meta("read_a")]);
     const next = snapshotFromMetas([
       meta("read_a", { name: "title", pgType: "text", notNull: false }),
     ]);
+    expect(rebuildTablesFromDiff(diffSnapshots(prev, next))).toEqual([]);
+  });
+
+  test("managed new NOT-NULL column ohne Default → rebuild (recreate, kann nicht in-place)", () => {
+    const prev = snapshotFromMetas([meta("read_a")]);
+    const next = snapshotFromMetas([
+      meta("read_a", { name: "title", pgType: "text", notNull: true }),
+    ]);
     expect(rebuildTablesFromDiff(diffSnapshots(prev, next))).toEqual(["read_a"]);
   });
 

package/src/db/rebuild-marker.ts

@@ -32,12 +32,28 @@ function markerPathFor(migrationsDir: string, migrationId: string): string {
   return join(migrationsDir, `${migrationId}.rebuild.json`);
 }
 
-// Only managed tables (event-stream derivatives) get rebuild markers — unmanaged carry real data, never rebuilt from events; sorted+deduped for stable PR diff.
+// Only managed tables (event-stream derivatives) get rebuild markers — unmanaged
+// carry real data, never rebuilt from events; sorted+deduped for stable PR diff.
+//
+// A changed table needs a rebuild ONLY when the generated SQL RECREATES it
+// (managedChangeRequiresRecreate: drop/NOT-NULL-w/o-default/unique-index/type-
+// or nullability-change) — then the table is emptied and must be re-derived from
+// events. A pure additive nullable column is an in-place `ADD COLUMN` ALTER that
+// already brings the table to the target state (same logic #181 applied to
+// index-/default-only changes). Rebuilding it anyway is wasted replay AND — the
+// bug this closes — a co-triggered rebuild can drop the fresh column (rebuild
+// runs from the rebuilding process's registry meta; on a rolling deploy an older
+// pod's meta lacks the column → shadow-swap wipes it → phantom migration + boot-
+// drift crash; see 0008_add_pending_deletion_request_id / #494 / #835).
+//
+// If a NEW additive column genuinely needs value-backfill from historical events
+// (a column DERIVED from existing event fields), opt in explicitly by hand-adding
+// a `NNNN_<name>.rebuild.json` next to the migration (readRebuildMarker reads it).
 export function rebuildTablesFromDiff(diff: SchemaDiff): readonly string[] {
   const names = new Set<string>();
   for (const t of diff.changedTables) {
     if (t.nextMeta.source !== "managed") continue;
-    if (t.newColumns.length > 0 || managedChangeRequiresRecreate(t)) names.add(t.tableName);
+    if (managedChangeRequiresRecreate(t)) names.add(t.tableName);
   }
   for (const t of diff.newTables) {
     if (t.source === "managed") names.add(t.tableName);

package/src/pipeline/__tests__/event-dispatcher.integration.test.ts

@@ -159,10 +159,20 @@ describe("event-dispatcher — happy path", () => {
     await stack.eventDispatcher?.runOnce();
     expect(captureA).toHaveLength(1);
 
+    const stateBefore = await getConsumerState(stack.db, qnA);
+
     const second = await stack.eventDispatcher?.runOnce();
     expect(second?.byConsumer[qnA]).toEqual({ processed: 0, failed: 0 });
     // Still only one — consumer correctly saw "nothing new past my cursor".
     expect(captureA).toHaveLength(1);
+
+    // No pending events means no write at all — an idle pass must not touch
+    // updated_at/status, otherwise every empty poll tick burns a WAL record.
+    const stateAfter = await getConsumerState(stack.db, qnA);
+    expect(stateAfter?.updatedAt.epochMilliseconds).toEqual(
+      stateBefore?.updatedAt.epochMilliseconds,
+    );
+    expect(stateAfter?.status).toBe(stateBefore?.status);
   });
 
   test("cursor advances only past successfully-consumed events", async () => {

package/src/pipeline/event-dispatcher.ts

@@ -524,9 +524,16 @@ export function createEventDispatcher(options: EventDispatcherOptions): EventDis
           span.setAttribute("consumer.skip_reason", acquired.skip);
           return;
         }
-        await markProcessing(tx, consumer.name, instanceId);
 
         const events = await fetchPendingEvents(tx, acquired.state.lastProcessedEventId, batchSize);
+        // skip: nothing to deliver — no markProcessing/persistConsumerOutcome write,
+        // so an idle consumer doesn't burn a WAL record on every poll tick.
+        if (events.length === 0) {
+          span.setAttribute("consumer.skip_reason", "no_pending_events");
+          return;
+        }
+        await markProcessing(tx, consumer.name, instanceId);
+
         const outcome = await deliverEvents(consumer, events, context, maxAttempts, acquired.state);
         processed = outcome.processed;
         failed = outcome.failed;