@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/pipeline/event-dispatcher.ts

@@ -1,6 +1,15 @@
-import { and, asc, eq, gt, sql } from "drizzle-orm";
 import { requestContext } from "../api/request-context";
 import type { DbConnection, DbTx, PgClient } from "../db/connection";
+import {
+  advanceConsumerPastEventReturning,
+  insertConsumerIfAbsent,
+  markConsumerProcessing,
+  selectConsumerForUpdateSkipLocked,
+  updateConsumerDeliveryOutcome,
+  updateConsumerStatusReturning,
+} from "../db/queries/event-consumer";
+import { selectEventsHeadId, selectNextEventIdAfter } from "../db/queries/event-store";
+import { coerceRow, extractTableInfo, selectMany } from "../db/query";
 import type { AppContext } from "../engine/types";
 import { SYSTEM_TENANT_ID } from "../engine/types/identifiers";
 import {
@@ -154,7 +163,30 @@ const DEFAULT_MAX_ATTEMPTS = 10;
 // dispatcher's main pass logic stays under ~50 LOC. Every helper takes an
 // explicit `tx` — none of them use the outer dispatcher's closure state.
 
-type ConsumerStateRow = typeof eventConsumerStateTable.$inferSelect;
+type ConsumerStateRowShape = {
+  readonly name: string;
+  readonly instanceId: string;
+  readonly lastProcessedEventId: bigint;
+  readonly status: string;
+  readonly attempts: number;
+  readonly lastError: string | null;
+  readonly updatedAt: Temporal.Instant;
+};
+type ConsumerStateRow = ConsumerStateRowShape;
+
+type StoredEventRow = {
+  readonly id: bigint;
+  readonly aggregateId: string;
+  readonly aggregateType: string;
+  readonly tenantId: string;
+  readonly version: number;
+  readonly type: string;
+  readonly eventVersion: number;
+  readonly payload: Record<string, unknown>;
+  readonly metadata: import("../event-store/event-store").EventMetadata;
+  readonly createdAt: Temporal.Instant;
+  readonly createdBy: string;
+};
 
 type AcquireOutcome =
   | { readonly state: ConsumerStateRow; readonly skip: null }
@@ -180,16 +212,13 @@ async function acquireConsumerState(
   name: string,
   instanceId: string,
 ): Promise<AcquireOutcome> {
-  const [state] = (await tx
-    .select()
-    .from(eventConsumerStateTable)
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    )
-    .for("update", { skipLocked: true })) as [ConsumerStateRow | undefined]; // @cast-boundary db-row
+  const rawState = await selectConsumerForUpdateSkipLocked(tx, name, instanceId);
+
+  if (!rawState) {
+    return { state: null, skip: "not_registered" };
+  }
+
+  const state = coerceRow(rawState, extractTableInfo(eventConsumerStateTable)) as ConsumerStateRow;
 
   if (!state) {
     // Either the row never existed (no pre-reg, no ensureRegistered) or
@@ -218,12 +247,7 @@ async function preRegisterConsumers(
 ): Promise<void> {
   for (const consumer of consumers) {
     const instanceId = consumerInstanceId(consumer, dispatcherInstanceId);
-    await db
-      .insert(eventConsumerStateTable)
-      .values({ name: consumer.name, instanceId, status: "idle" })
-      .onConflictDoNothing({
-        target: [eventConsumerStateTable.name, eventConsumerStateTable.instanceId],
-      });
+    await insertConsumerIfAbsent(db, consumer.name, instanceId);
   }
 }
 
@@ -249,28 +273,20 @@ function consumerInstanceId(
 // lock already guarantees single-writer semantics; this is purely
 // informational (and resets on commit to idle/dead via persistConsumerOutcome).
 async function markProcessing(tx: DbTx, name: string, instanceId: string): Promise<void> {
-  await tx
-    .update(eventConsumerStateTable)
-    .set({ status: "processing", updatedAt: sql`now()` })
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    );
+  await markConsumerProcessing(tx, name, instanceId);
 }
 
 async function fetchPendingEvents(
   tx: DbTx,
   cursor: bigint,
   batchSize: number,
-): Promise<ReadonlyArray<typeof eventsTable.$inferSelect>> {
-  return (await tx
-    .select()
-    .from(eventsTable)
-    .where(gt(eventsTable.id, cursor))
-    .orderBy(asc(eventsTable.id))
-    .limit(batchSize)) as ReadonlyArray<typeof eventsTable.$inferSelect>; // @cast-boundary db-row
+): Promise<ReadonlyArray<StoredEventRow>> {
+  return (await selectMany(
+    tx,
+    eventsTable,
+    { id: { gt: cursor } },
+    { orderBy: { col: "id", direction: "asc" }, limit: batchSize },
+  )) as ReadonlyArray<StoredEventRow>; // @cast-boundary db-row
 }
 
 type DeliveryOutcome = {
@@ -282,7 +298,7 @@ type DeliveryOutcome = {
   readonly failed: number;
 };
 
-function rowToStoredEvent(row: typeof eventsTable.$inferSelect): StoredEvent {
+function rowToStoredEvent(row: StoredEventRow): StoredEvent {
   return {
     id: String(row.id),
     aggregateId: row.aggregateId,
@@ -305,7 +321,7 @@ function rowToStoredEvent(row: typeof eventsTable.$inferSelect): StoredEvent {
 // restartConsumer / skipPoisonEvent).
 async function deliverEvents(
   consumer: EventConsumer,
-  events: ReadonlyArray<typeof eventsTable.$inferSelect>,
+  events: ReadonlyArray<StoredEventRow>,
   context: AppContext,
   maxAttempts: number,
   state: ConsumerStateRow,
@@ -376,21 +392,7 @@ async function persistConsumerOutcome(
   instanceId: string,
   outcome: DeliveryOutcome,
 ): Promise<void> {
-  await tx
-    .update(eventConsumerStateTable)
-    .set({
-      lastProcessedEventId: outcome.cursor,
-      attempts: outcome.attempts,
-      status: outcome.deadLettered ? "dead" : "idle",
-      lastError: outcome.lastError,
-      updatedAt: sql`now()`,
-    })
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    );
+  await updateConsumerDeliveryOutcome(tx, name, instanceId, outcome);
 }
 
 // Emit the lag gauge inside the consumer pass's tx so ops sees a snapshot
@@ -403,13 +405,7 @@ async function emitLagFromTx(
   cursor: bigint,
   meter: Meter,
 ): Promise<void> {
-  const result = await tx.execute(
-    sql`SELECT COALESCE(MAX(id), 0)::bigint AS head FROM kumiko_events`,
-  );
-  // @cast-boundary db-row — raw drizzle.execute() COALESCE-aggregate row
-  const rows = Array.isArray(result) ? (result as Array<{ head?: bigint | string | null }>) : []; // @cast-boundary db-row
-  const raw = rows[0]?.head;
-  const head = typeof raw === "bigint" ? raw : BigInt(raw ?? 0);
+  const head = await selectEventsHeadId(tx);
   const lag = head > cursor ? Number(head - cursor) : 0;
   emitEventConsumerLag(meter, { consumer: consumerName, instanceId }, lag);
 }
@@ -535,7 +531,7 @@ export function createEventDispatcher(options: EventDispatcherOptions): EventDis
     });
 
     try {
-      await db.transaction(async (tx) => {
+      await db.begin(async (tx: DbTx) => {
         const acquired = await acquireConsumerState(tx, consumer.name, instanceId);
         // skip: another instance holds the lock, or the consumer is
         // disabled/dead. Nothing to deliver this pass.
@@ -701,9 +697,7 @@ export function createEventDispatcher(options: EventDispatcherOptions): EventDis
 //                     lastError=null, status="idle". For events that will
 //                     never succeed (broken payload, removed feature code).
 
-function normalizeConsumerState(
-  row: typeof eventConsumerStateTable.$inferSelect,
-): ConsumerRecoveryState {
+function normalizeConsumerState(row: ConsumerStateRowShape): ConsumerRecoveryState {
   return {
     name: row.name,
     instanceId: row.instanceId,
@@ -735,16 +729,11 @@ async function requireConsumerRow(
   db: DbConnection,
   name: string,
   instanceId: string,
-): Promise<typeof eventConsumerStateTable.$inferSelect> {
-  const [row] = await db
-    .select()
-    .from(eventConsumerStateTable)
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    );
+): Promise<ConsumerStateRowShape> {
+  const [row] = await selectMany<ConsumerStateRow>(db, eventConsumerStateTable, {
+    name,
+    instanceId,
+  });
   if (!row) {
     throw new Error(
       `Consumer "${name}" (instance_id="${instanceId}") has no state row — it hasn't run yet, the name is misspelled, or the instance is misspelled. ` +
@@ -765,16 +754,9 @@ export async function restartConsumer(
       `Consumer "${name}" (instance_id="${instanceId}") is not dead (status="${before.status}"). Restart only applies to dead consumers; use "enable" for a disabled one.`,
     );
   }
-  const [updated] = await db
-    .update(eventConsumerStateTable)
-    .set({ status: "idle", attempts: 0, lastError: null, updatedAt: sql`now()` })
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    )
-    .returning();
+  const raw = await updateConsumerStatusReturning(db, name, instanceId, "idle");
+  const updated =
+    raw && (coerceRow(raw, extractTableInfo(eventConsumerStateTable)) as ConsumerStateRow);
   if (!updated) {
     throw new Error(
       `Consumer "${name}" (instance_id="${instanceId}") vanished between read and write — retry.`,
@@ -789,16 +771,9 @@ export async function disableConsumer(
   instanceId: string = SHARED_INSTANCE_SENTINEL,
 ): Promise<ConsumerRecoveryState> {
   await requireConsumerRow(db, name, instanceId);
-  const [updated] = await db
-    .update(eventConsumerStateTable)
-    .set({ status: "disabled", updatedAt: sql`now()` })
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    )
-    .returning();
+  const raw = await updateConsumerStatusReturning(db, name, instanceId, "disabled");
+  const updated =
+    raw && (coerceRow(raw, extractTableInfo(eventConsumerStateTable)) as ConsumerStateRow);
   if (!updated) {
     throw new Error(
       `Consumer "${name}" (instance_id="${instanceId}") vanished between read and write — retry.`,
@@ -818,16 +793,9 @@ export async function enableConsumer(
       `Consumer "${name}" (instance_id="${instanceId}") is not disabled (status="${before.status}"). Enable only flips disabled → idle; use "restart" for a dead consumer.`,
     );
   }
-  const [updated] = await db
-    .update(eventConsumerStateTable)
-    .set({ status: "idle", attempts: 0, lastError: null, updatedAt: sql`now()` })
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    )
-    .returning();
+  const raw = await updateConsumerStatusReturning(db, name, instanceId, "idle");
+  const updated =
+    raw && (coerceRow(raw, extractTableInfo(eventConsumerStateTable)) as ConsumerStateRow);
   if (!updated) {
     throw new Error(
       `Consumer "${name}" (instance_id="${instanceId}") vanished between read and write — retry.`,
@@ -846,48 +814,25 @@ export async function skipPoisonEvent(
   instanceId: string = SHARED_INSTANCE_SENTINEL,
 ): Promise<ConsumerRecoveryState & { readonly skippedEventId: bigint | null }> {
   const before = await requireConsumerRow(db, name, instanceId);
-  return db.transaction(async (tx) => {
-    const [poison] = (await tx
-      .select({ id: eventsTable.id })
-      .from(eventsTable)
-      .where(gt(eventsTable.id, before.lastProcessedEventId))
-      .orderBy(asc(eventsTable.id))
-      .limit(1)) as ReadonlyArray<{ id: bigint }>; // @cast-boundary db-row
-    if (!poison) {
-      const [unchanged] = await tx
-        .select()
-        .from(eventConsumerStateTable)
-        .where(
-          and(
-            eq(eventConsumerStateTable.name, name),
-            eq(eventConsumerStateTable.instanceId, instanceId),
-          ),
-        );
+  return db.begin(async (tx: DbTx) => {
+    const poisonId = await selectNextEventIdAfter(tx, before.lastProcessedEventId);
+    if (poisonId === null) {
+      const [unchanged] = await selectMany<ConsumerStateRow>(tx, eventConsumerStateTable, {
+        name,
+        instanceId,
+      });
       if (!unchanged)
         throw new Error(`Consumer "${name}" (instance_id="${instanceId}") vanished — retry.`);
       return { ...normalizeConsumerState(unchanged), skippedEventId: null };
     }
-    const [updated] = await tx
-      .update(eventConsumerStateTable)
-      .set({
-        lastProcessedEventId: poison.id,
-        status: "idle",
-        attempts: 0,
-        lastError: null,
-        updatedAt: sql`now()`,
-      })
-      .where(
-        and(
-          eq(eventConsumerStateTable.name, name),
-          eq(eventConsumerStateTable.instanceId, instanceId),
-        ),
-      )
-      .returning();
+    const raw = await advanceConsumerPastEventReturning(tx, name, instanceId, poisonId);
+    const updated =
+      raw && (coerceRow(raw, extractTableInfo(eventConsumerStateTable)) as ConsumerStateRow);
     if (!updated)
       throw new Error(
         `Consumer "${name}" (instance_id="${instanceId}") vanished mid-skip — retry.`,
       );
-    return { ...normalizeConsumerState(updated), skippedEventId: poison.id };
+    return { ...normalizeConsumerState(updated), skippedEventId: poisonId };
   });
 }
 
@@ -905,15 +850,10 @@ export async function getConsumerState(
   readonly lastError: string | null;
   readonly updatedAt: Temporal.Instant;
 } | null> {
-  const [row] = await db
-    .select()
-    .from(eventConsumerStateTable)
-    .where(
-      and(
-        eq(eventConsumerStateTable.name, name),
-        eq(eventConsumerStateTable.instanceId, instanceId),
-      ),
-    );
+  const [row] = await selectMany<ConsumerStateRow>(db, eventConsumerStateTable, {
+    name,
+    instanceId,
+  });
   if (!row) return null;
   return {
     name: row.name,
@@ -947,7 +887,7 @@ export async function listConsumersWithState(
     readonly lastError: string | null;
   }>
 > {
-  const stateRows = await db.select().from(eventConsumerStateTable);
+  const stateRows = await selectMany<ConsumerStateRow>(db, eventConsumerStateTable);
   const registered = new Set(registeredNames);
 
   // Materialize one output row per (name, instance_id). Registered names

package/src/pipeline/event-retention.ts

@@ -1,5 +1,6 @@
-import { and, getTableName, inArray, lt, sql } from "drizzle-orm";
 import type { DbConnection } from "../db/connection";
+import { lockEventConsumersShareMode } from "../db/queries/event-consumer";
+import { deleteMany, selectMany, transaction } from "../db/query";
 import { eventsTable } from "../event-store";
 import { eventConsumerStateTable } from "./event-consumer-state";
 
@@ -83,7 +84,7 @@ export async function pruneEvents(
   const aggregateTypes = options.aggregateTypes;
   const dryRun = options.dryRun === true;
 
-  return db.transaction(async (tx) => {
+  return transaction(db, async (tx) => {
     // Serialise against consumer-bootstrap INSERTs. Without this, the race
     // is: prune reads consumers (snapshot misses a consumer bootstrapping
     // in a parallel tx) → consumer commits its row with
@@ -96,21 +97,13 @@ export async function pruneEvents(
     // (cursor advances) do too, but prune is measured in milliseconds and
     // pausing cursor advances for that window is cheap insurance against
     // a silent data-loss bug.
-    //
-    // Drizzle can't express LOCK TABLE — drop to raw SQL with the table
-    // name identifier so a future table-rename is caught at compile time.
-    await tx.execute(sql.raw(`LOCK TABLE ${getTableName(eventConsumerStateTable)} IN SHARE MODE`));
+    await lockEventConsumersShareMode(tx);
 
     // Step 1 — collect candidate event ids.
-    const candidates = await tx
-      .select({ id: eventsTable.id })
-      .from(eventsTable)
-      .where(
-        and(
-          inArray(eventsTable.aggregateType, [...aggregateTypes]),
-          lt(eventsTable.createdAt, cutoff),
-        ),
-      );
+    const candidates = await selectMany<{ id: bigint }>(tx, eventsTable, {
+      aggregateType: [...aggregateTypes],
+      createdAt: { lt: cutoff },
+    });
 
     if (candidates.length === 0) {
       return { deletedCount: 0, cutoff, aggregateTypes, dryRun };
@@ -127,10 +120,10 @@ export async function pruneEvents(
     // The SHARE lock above guarantees this SELECT sees a complete view:
     // no new consumer can INSERT a fresh-cursor row between here and the
     // DELETE below.
-    const activeConsumers = await tx
-      .select()
-      .from(eventConsumerStateTable)
-      .where(sql`${eventConsumerStateTable.status} <> 'disabled'`);
+    const activeConsumers = await selectMany<{
+      name: string;
+      lastProcessedEventId: bigint;
+    }>(tx, eventConsumerStateTable, { status: { ne: "disabled" } });
 
     for (const consumer of activeConsumers) {
       if (consumer.lastProcessedEventId < maxCandidateId) {
@@ -144,11 +137,8 @@ export async function pruneEvents(
 
     // Step 3 — actual delete, bounded to the candidate set.
     const candidateIds = candidates.map((c) => c.id);
-    const deleted = await tx
-      .delete(eventsTable)
-      .where(inArray(eventsTable.id, candidateIds))
-      .returning({ id: eventsTable.id });
+    await deleteMany(tx, eventsTable, { id: candidateIds });
 
-    return { deletedCount: deleted.length, cutoff, aggregateTypes, dryRun: false };
+    return { deletedCount: candidateIds.length, cutoff, aggregateTypes, dryRun: false };
   });
 }

package/src/pipeline/msp-rebuild.ts

@@ -1,5 +1,12 @@
-import { and, asc, eq, getTableName, inArray, sql } from "drizzle-orm";
-import type { DbConnection, DbRunner } from "../db/connection";
+import type { DbConnection, DbRunner, DbTx } from "../db/connection";
+import {
+  markConsumerRebuildFailed,
+  resetConsumerForMspRebuild,
+  selectConsumerForUpdate,
+  updateConsumerRebuildCursor,
+} from "../db/queries/event-consumer";
+import { truncateTable } from "../db/queries/table-ops";
+import { selectMany } from "../db/query";
 import type { Registry, TenantId } from "../engine/types";
 import { InternalError } from "../errors";
 import { eventsTable, type StoredEvent, upcastStoredEvent } from "../event-store";
@@ -7,7 +14,7 @@ import { loadAggregate, loadAggregateAsOf } from "../event-store/event-store";
 import { upcastStoredEvents } from "../event-store/upcaster";
 import { emitProjectionRebuild } from "../observability/standard-metrics";
 import type { Meter } from "../observability/types/metric";
-import { eventConsumerStateTable, SHARED_INSTANCE_SENTINEL } from "./event-consumer-state";
+import { SHARED_INSTANCE_SENTINEL } from "./event-consumer-state";
 import type { MultiStreamApplyContext } from "./multi-stream-apply-context";
 import type { RebuildResult } from "./projection-rebuild";
 
@@ -101,57 +108,35 @@ export async function rebuildMultiStreamProjection(
   let lastProcessedEventId = 0n;
 
   try {
-    await db.transaction(async (tx) => {
-      // Upsert + lock the consumer row. Rebuild always targets the
-      // SHARED-delivery shard: per-instance MSPs are side-effect-only (no
-      // table, so the guard above refuses them anyway), and rebuild's
-      // purpose is to rematerialize one persistent read-model, not fan
-      // out a local cache reset across instances. The FOR UPDATE on the
-      // next SELECT is what blocks concurrent rebuilds of the same MSP;
-      // live dispatcher passes use SKIP LOCKED on this row and will bail
-      // silently while we hold it.
-      await tx
-        .insert(eventConsumerStateTable)
-        .values({
-          name: mspName,
-          instanceId: SHARED_INSTANCE_SENTINEL,
-          lastProcessedEventId: 0n,
-          status: "idle",
-        })
-        .onConflictDoUpdate({
-          target: [eventConsumerStateTable.name, eventConsumerStateTable.instanceId],
-          set: {
-            lastProcessedEventId: 0n,
-            status: "idle",
-            attempts: 0,
-            lastError: null,
-            updatedAt: sql`now()`,
-          },
-        });
-      await tx
-        .select()
-        .from(eventConsumerStateTable)
-        .where(
-          and(
-            eq(eventConsumerStateTable.name, mspName),
-            eq(eventConsumerStateTable.instanceId, SHARED_INSTANCE_SENTINEL),
-          ),
-        )
-        .for("update");
+    await db.begin(async (tx: DbTx) => {
+      await resetConsumerForMspRebuild(tx, mspName, SHARED_INSTANCE_SENTINEL);
+      await selectConsumerForUpdate(tx, mspName, SHARED_INSTANCE_SENTINEL);
 
-      // msp.table is narrowed by the upfront guard; the assertion here is
-      // for TS inside the async closure (narrowing doesn't cross the
-      // transaction boundary).
-      const tableName = getTableName(msp.table as NonNullable<typeof msp.table>); // @cast-boundary db-operator
-      await tx.execute(sql.raw(`TRUNCATE TABLE ${quoteIdent(tableName)}`));
+      const mspTable = msp.table as NonNullable<typeof msp.table>;
+      const tableName = getTableName(mspTable);
+      await truncateTable(tx, tableName);
 
       const subscribedTypes = Object.keys(msp.apply);
       if (subscribedTypes.length > 0) {
-        const events = (await tx
-          .select()
-          .from(eventsTable)
-          .where(inArray(eventsTable.type, subscribedTypes))
-          .orderBy(asc(eventsTable.id))) as ReadonlyArray<typeof eventsTable.$inferSelect>; // @cast-boundary db-row
+        type EventRow = {
+          id: bigint;
+          aggregateId: string;
+          aggregateType: string;
+          tenantId: TenantId;
+          version: number;
+          type: string;
+          eventVersion: number;
+          payload: Record<string, unknown>;
+          metadata: import("../event-store/event-store").EventMetadata;
+          createdAt: Temporal.Instant;
+          createdBy: string;
+        };
+        const events = await selectMany<EventRow>(
+          tx,
+          eventsTable,
+          { type: [...subscribedTypes] },
+          { orderBy: { col: "id", direction: "asc" } },
+        );
 
         const upcasters = registry.getEventUpcasters();
         for (const row of events) {
@@ -170,44 +155,27 @@ export async function rebuildMultiStreamProjection(
           };
           const storedEvent = await upcastStoredEvent(raw, upcasters, {
             db: tx,
-            tenantId: row.tenantId as TenantId, // @cast-boundary db-row
+            tenantId: row.tenantId,
           });
           const applyFn = msp.apply[row.type];
           if (!applyFn) continue;
-          const rebuildCtx = createRebuildCtx(registry, tx, row.tenantId as TenantId); // @cast-boundary db-row
+          const rebuildCtx = createRebuildCtx(registry, tx, row.tenantId);
           await applyFn(storedEvent, tx, rebuildCtx);
           eventsProcessed++;
           lastProcessedEventId = row.id;
         }
       }
 
-      await tx
-        .update(eventConsumerStateTable)
-        .set({
-          lastProcessedEventId,
-          status: "idle",
-          attempts: 0,
-          lastError: null,
-          updatedAt: sql`now()`,
-        })
-        .where(
-          and(
-            eq(eventConsumerStateTable.name, mspName),
-            eq(eventConsumerStateTable.instanceId, SHARED_INSTANCE_SENTINEL),
-          ),
-        );
+      await updateConsumerRebuildCursor(
+        tx,
+        mspName,
+        SHARED_INSTANCE_SENTINEL,
+        lastProcessedEventId,
+      );
     });
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
-    await db
-      .update(eventConsumerStateTable)
-      .set({ status: "dead", lastError: message, updatedAt: sql`now()` })
-      .where(
-        and(
-          eq(eventConsumerStateTable.name, mspName),
-          eq(eventConsumerStateTable.instanceId, SHARED_INSTANCE_SENTINEL),
-        ),
-      );
+    await markConsumerRebuildFailed(db, mspName, SHARED_INSTANCE_SENTINEL, message);
     if (deps.meter) {
       emitProjectionRebuild(
         deps.meter,
@@ -237,6 +205,14 @@ export async function rebuildMultiStreamProjection(
   return result;
 }
 
-function quoteIdent(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`;
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+function getTableName(table: unknown): string {
+  if (typeof table !== "object" || table === null) {
+    throw new InternalError({ message: "msp-rebuild: msp.table is not a pgTable object" });
+  }
+  const name = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  if (typeof name !== "string") {
+    throw new InternalError({ message: "msp-rebuild: msp.table missing drizzle name symbol" });
+  }
+  return name;
 }