@cosmicdrift/kumiko-dev-server 0.220.1 → 0.222.0

package/bin/kumiko-upgrade.ts

@@ -15,4 +15,5 @@ import { runUpgradeCli } from "@cosmicdrift/kumiko-framework/upgrade-cli";
 const out = { log: (l: string) => console.log(l), err: (l: string) => console.error(l) };
 const appCwd = process.env["INIT_CWD"] ?? process.cwd();
 const code = await runUpgradeCli(process.argv.slice(2), appCwd, out);
-process.exit(code);
+// Let the event loop drain stdout (piped by guard-upgrade-state) before exit.
+process.exitCode = code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.220.1",
+  "version": "0.222.0",
   "description": "Dev-tooling for Kumiko apps: local dev-server bootstrap (runDevApp), scaffolding, codegen. Its compose-stacks/env-schema subpaths are consumed at prod boot too — see @cosmicdrift/kumiko-server-runtime for the prod runner itself.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -59,9 +59,9 @@
     "kumiko-upgrade": "./bin/kumiko-upgrade.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.220.1",
-    "@cosmicdrift/kumiko-framework": "0.220.1",
-    "@cosmicdrift/kumiko-server-runtime": "0.220.1",
+    "@cosmicdrift/kumiko-bundled-features": "0.222.0",
+    "@cosmicdrift/kumiko-framework": "0.222.0",
+    "@cosmicdrift/kumiko-server-runtime": "0.222.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

package/src/__tests__/create-kumiko-server.integration.test.ts

@@ -2,6 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { NO_ROUTE_MATCH_HEADER_NAME } from "@cosmicdrift/kumiko-framework/api";
 import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
 import {
   createBooleanField,
@@ -507,3 +508,66 @@ describe("createKumikoServer — hot-reload broadcast", () => {
     }
   });
 });
+
+// kumiko-framework#2435: tryHonoFirst used to decide "no route matched"
+// purely from the status code — a matched httpRoute answering 404 on
+// purpose (e.g. default-deny reads) was indistinguishable from an
+// unregistered path and got silently rewritten to the SPA shell with
+// status 200. Drives the REAL fetch-handler end to end (real Postgres,
+// real Hono app via createKumikoServer) so the fix's actual wiring
+// (buildServer's app.notFound() marker + tryHonoFirst reading it) is
+// under test, not just the pure-function pin in try-hono-first.test.ts.
+const probeHttpRouteFeature = defineFeature("dev-server-probe-http-route", (r) => {
+  r.httpRoute({
+    method: "GET",
+    path: "/probe/:id",
+    anonymous: true,
+    handler: async (c) => {
+      const id = c.req.param("id");
+      if (id === "missing") return c.text("not found", 404);
+      return c.text(`probe:${id}`, 200);
+    },
+  });
+});
+
+describe("createKumikoServer — tryHonoFirst 404-vs-router-miss (#2435)", () => {
+  async function bootWithProbeRoute(): Promise<KumikoServerHandle> {
+    handle = await createKumikoServer({
+      features: [probeHttpRouteFeature],
+      port: 0,
+      installSignalHandlers: false,
+    });
+    return handle;
+  }
+
+  test("gematchte httpRoute mit bewusster 404 bleibt 404 (keine SPA-Maskierung)", async () => {
+    const h = await bootWithProbeRoute();
+    const res = await h.fetch(new Request("http://localhost/probe/missing"));
+    expect(res.status).toBe(404);
+    expect(res.headers.get("content-type") ?? "").not.toMatch(/text\/html/);
+    expect(await res.text()).toBe("not found");
+  });
+
+  test("gematchte httpRoute mit Treffer antwortet normal (200)", async () => {
+    const h = await bootWithProbeRoute();
+    const res = await h.fetch(new Request("http://localhost/probe/exists"));
+    expect(res.status).toBe(200);
+    expect(await res.text()).toBe("probe:exists");
+  });
+
+  test("unbekannte SPA-Route liefert weiterhin die SPA-Shell (200 HTML)", async () => {
+    const h = await bootWithProbeRoute();
+    const res = await h.fetch(new Request("http://localhost/some/client-side/route"));
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toMatch(/text\/html/);
+    expect(await res.text()).toMatch(/<div id="root">/);
+  });
+
+  test("kein Router-miss-Marker leakt an den Client", async () => {
+    const h = await bootWithProbeRoute();
+    const missRes = await h.fetch(new Request("http://localhost/some/client-side/route"));
+    const deniedRes = await h.fetch(new Request("http://localhost/probe/missing"));
+    expect(missRes.headers.has(NO_ROUTE_MATCH_HEADER_NAME)).toBe(false);
+    expect(deniedRes.headers.has(NO_ROUTE_MATCH_HEADER_NAME)).toBe(false);
+  });
+});

package/src/__tests__/env-schema.integration.test.ts

@@ -42,6 +42,11 @@ describe("public-export smoke", () => {
   it("re-exports frameworkCoreEnvSchema via dev-server's package entry", () => {
     expect(devServerPublicApi.frameworkCoreEnvSchema).toBe(frameworkCoreEnvSchema);
   });
+
+  it("re-exports frameworkCoreEnvSchema via the env-schema subpath", async () => {
+    const viaSubpath = await import("@cosmicdrift/kumiko-dev-server/env-schema");
+    expect(viaSubpath.frameworkCoreEnvSchema).toBe(frameworkCoreEnvSchema);
+  });
 });
 
 describe("runProdApp envSchema integration", () => {

package/src/__tests__/runtime-classification.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { frameworkCoreEnvSchema as envSchemaViaRelative } from "../env-schema";
 
 // Mirrors infra/guards/runtime-isolation-classify.ts `classifyByDirective`
 // as of kumiko-framework#2337 (first 600 bytes, first 8 lines,
@@ -25,17 +24,3 @@ describe("compose-stacks.ts runtime directive", () => {
     expect(classifyByDirective(composeStacksPath)).toBe("runtime");
   });
 });
-
-describe("@cosmicdrift/kumiko-dev-server/env-schema subpath", () => {
-  it("resolves the same schema as the relative import, and it parses", async () => {
-    const { frameworkCoreEnvSchema: envSchemaViaSubpath } = await import(
-      "@cosmicdrift/kumiko-dev-server/env-schema"
-    );
-    expect(envSchemaViaSubpath).toBe(envSchemaViaRelative);
-    const parsed = envSchemaViaSubpath.parse({
-      DATABASE_URL: "postgres://localhost:5432/db",
-      REDIS_URL: "redis://localhost:6379",
-    });
-    expect(parsed.PORT).toBe("3000");
-  });
-});

package/src/__tests__/scaffold-app.test.ts

@@ -276,8 +276,10 @@ describe("scaffoldApp", () => {
 
     const main = readFileSync(join(dest, "bin/main.ts"), "utf-8");
     expect(main).toContain('from "@cosmicdrift/kumiko-framework/crypto"');
+    expect(main).toContain("requireKmsWiring(process.env");
     expect(main).toContain("resolveKmsWiring(process.env");
-    expect(main).toContain('if ("allowPlaintextPii" in kmsWiring)');
+    expect(main).toContain('process.env["NODE_ENV"] === "production"');
+    expect(main).not.toContain('if ("allowPlaintextPii" in kmsWiring)');
     expect(main).toContain("...kmsWiring,");
   });
 

package/src/__tests__/schema-apply.integration.test.ts

@@ -12,11 +12,31 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   asRawClient,
+  buildEntityTable,
   createDbConnection,
+  createEventStoreExecutor,
+  createTenantDb,
   type DbConnection,
+  integer,
+  table as pgTable,
+  selectMany,
   tableExists,
+  uuid,
 } from "@cosmicdrift/kumiko-framework/db";
-import { createTestDb, type TestDb } from "@cosmicdrift/kumiko-framework/stack";
+import {
+  createEntity,
+  createTextField,
+  defineApply,
+  defineFeature,
+  type ProjectionDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+import {
+  createTestDb,
+  type TestDb,
+  TestUsers,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
 import { runSchemaApply } from "../schema-apply";
 
 let testDb: TestDb;
@@ -76,7 +96,7 @@ describe("runSchemaApply", () => {
     expect(await tableExists(conn.db, "public.read_thing")).toBe(true);
   });
 
-  test("rebuild-Marker für nicht-registrierte Tabelle → kein Crash, 0, aber laut warnen (522/3)", async () => {
+  test("rebuild-Marker für nicht-registrierte Tabelle → kein Crash, 0, aber laut warnen (522/3, #2464)", async () => {
     writeFileSync(
       join(migDir, "0002_more.sql"),
       `CREATE TABLE "read_more" ("id" text PRIMARY KEY);`,
@@ -86,10 +106,86 @@ describe("runSchemaApply", () => {
       JSON.stringify({ version: 1, tables: ["read_more"] }),
     );
 
-    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    // runPendingRebuilds (not the old local helper) owns this warning now —
+    // it logs via createFallbackLogger(...).error(...), not console.warn.
+    const error = spyOn(console, "error").mockImplementation(() => {});
     expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
     expect(await tableExists(conn.db, "public.read_more")).toBe(true);
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Table "read_more"'));
-    warn.mockRestore();
+    expect(error).toHaveBeenCalledWith(expect.stringContaining("read_more"), expect.anything());
+    error.mockRestore();
+  });
+
+  test("failed projection rebuild stays queued and is retried on a later apply with zero new migrations (#2464)", async () => {
+    // Isolate from any pending-rebuild rows the earlier tests in this file left.
+    await asRawClient(conn.db).unsafe(`DROP TABLE IF EXISTS kumiko_pending_rebuilds`);
+
+    const groupId = "00000000-0000-4000-8000-0000000000b1";
+    let failApply = true;
+
+    const failItemEntity = createEntity({
+      table: "read_apply_fail_items",
+      fields: {
+        groupId: createTextField({ required: true }),
+        name: createTextField({ required: true }),
+      },
+    });
+    const failItemTable = buildEntityTable("apply-fail-item", failItemEntity);
+    const failCountsTable = pgTable("read_apply_fail_counts", {
+      groupId: uuid("group_id").primaryKey(),
+      tenantId: uuid("tenant_id").notNull(),
+      itemCount: integer("item_count").notNull().default(0),
+    });
+    const failCountsProjection: ProjectionDefinition = {
+      name: "apply-fail-counts",
+      source: "apply-fail-item",
+      table: failCountsTable,
+      apply: {
+        "apply-fail-item.created": defineApply<{ groupId: string }>(async (event, tx) => {
+          if (failApply) throw new Error("simulated rebuild failure (test)");
+          await asRawClient(tx).unsafe(
+            `INSERT INTO "read_apply_fail_counts" (group_id, tenant_id, item_count) VALUES ($1::uuid, $2::uuid, 1)
+             ON CONFLICT (group_id) DO UPDATE SET item_count = read_apply_fail_counts.item_count + 1`,
+            [event.payload.groupId, event.tenantId],
+          );
+        }),
+      },
+    };
+    const feature = defineFeature("applyfailtest", (r) => {
+      r.entity("apply-fail-item", failItemEntity);
+      r.projection(failCountsProjection);
+    });
+
+    await unsafeCreateEntityTable(conn.db, failItemEntity, "apply-fail-item");
+    await unsafePushTables(conn.db, { readApplyFailCounts: failCountsTable });
+
+    const tdb = createTenantDb(conn.db, TestUsers.admin.tenantId);
+    const executor = createEventStoreExecutor(failItemTable, failItemEntity, {
+      entityName: "apply-fail-item",
+    });
+    await executor.create({ groupId, name: "x" }, TestUsers.admin, tdb);
+
+    writeFileSync(join(migDir, "0003_touch_fail_counts.sql"), "SELECT 1;\n");
+    writeFileSync(
+      join(migDir, "0003_touch_fail_counts.rebuild.json"),
+      JSON.stringify({ version: 1, tables: ["read_apply_fail_counts"] }),
+    );
+
+    const error = spyOn(console, "error").mockImplementation(() => {});
+    const firstRun = await runSchemaApply({ features: [feature], includeBundled: false, appCwd });
+    error.mockRestore();
+    // Fail-loud: a failed rebuild must surface as a non-zero exit, not a
+    // silent 0 — the migration itself is now tracked applied, so without a
+    // persisted queue this table's rebuild would never be retried again.
+    expect(firstRun).toBe(1);
+    const [rowAfterFail] = await selectMany(conn.db, failCountsTable, { groupId });
+    expect(rowAfterFail).toBeUndefined();
+
+    // Second apply: no new migrations (0003 is already tracked), yet the
+    // queued table must still be retried from kumiko_pending_rebuilds.
+    failApply = false;
+    const secondRun = await runSchemaApply({ features: [feature], includeBundled: false, appCwd });
+    expect(secondRun).toBe(0);
+    const [rowAfterRetry] = await selectMany(conn.db, failCountsTable, { groupId });
+    expect(rowAfterRetry?.itemCount).toBe(1);
   });
 });

package/src/create-kumiko-server.ts

@@ -41,7 +41,10 @@ import {
   canResolveTailwindStylesheet,
   resolveTailwindCli,
 } from "@cosmicdrift/kumiko-server-runtime/resolve-tailwind-cli";
-import { tryHonoFirst } from "@cosmicdrift/kumiko-server-runtime/try-hono-first";
+import {
+  stripNoRouteMatchHeader,
+  tryHonoFirst,
+} from "@cosmicdrift/kumiko-server-runtime/try-hono-first";
 
 // Runtime-detection. The dev-server is meant to run under Bun (Kumiko's
 // target runtime), but the test-suite runs under vitest on Node — we
@@ -941,7 +944,11 @@ export async function createKumikoServer(
       return htmlResponse("client", true);
     }
 
-    return stack.app.fetch(req);
+    // Bypasses tryHonoFirst entirely (API paths, dotted paths, /sse,
+    // non-GET/HEAD), so the router-miss marker must be stripped here too —
+    // otherwise an unmatched path would leak it straight to the client
+    // (see try-hono-first.ts's header-hygiene note).
+    return stripNoRouteMatchHeader(await stack.app.fetch(req));
   };
 
   // --- HTTP server (Bun only) ---

package/src/env-schema.ts

@@ -1,3 +1,7 @@
+// @runtime runtime
+// Consumed at prod boot via composeEnvSchema (same as compose-stacks),
+// not only by tooling — keep runtime-isolation-safe (kumiko-framework#2340).
+//
 // Framework-core env-schema — the vars that runProdApp + buildServer
 // + the connection-pool read directly from process.env today. Apps merge
 // this into their app-wide schema via `composeEnvSchema({ core, ... })`.

package/src/scaffold-app.ts

@@ -439,7 +439,7 @@ function renderMain(appName: string): string {
   });
   sf.addImportDeclaration({
     moduleSpecifier: "@cosmicdrift/kumiko-framework/crypto",
-    namedImports: ["resolveKmsWiring"],
+    namedImports: ["requireKmsWiring", "resolveKmsWiring"],
   });
   sf.addImportDeclaration({
     moduleSpecifier: "../src/run-config",
@@ -482,34 +482,40 @@ function renderMain(appName: string): string {
   });
 
   // Subject-key KMS for the pii-annotated entities the --yes recommended set
-  // mounts (user, tenant-invitation, fileRef). Without the PLATFORM_KEK /
-  // SUBJECT_KEYS_DATABASE_URL / KUMIKO_BLIND_INDEX_KEY trio this falls back
-  // to plaintext PII with a loud boot warning — fine to get running locally,
-  // never for a real deploy (kumiko-framework#2330).
+  // mounts (user, tenant-invitation, fileRef). Local/dev may omit the trio
+  // (plaintext + loud warning); NODE_ENV=production uses requireKmsWiring so
+  // a real deploy cannot silently store plaintext PII (fw#2317 / #2339).
+  // assertPiiBootInvariants already warns on the plaintext path — no duplicate console.warn.
   sf.addVariableStatement({
     declarationKind: VariableDeclarationKind.Const,
     declarations: [
       {
-        name: "kmsWiring",
+        name: "kmsOpts",
         initializer: (writer) => {
-          writer.write("resolveKmsWiring(process.env, ").inlineBlock(() => {
-            writer.writeLine(`logPrefix: "[${appName}]",`);
-            writer.writeLine(
-              `plaintextReason: "no PLATFORM_KEK / SUBJECT_KEYS_DATABASE_URL / KUMIKO_BLIND_INDEX_KEY set — see .env.example",`,
-            );
-          });
-          writer.write(")");
+          writer.write("{").newLine();
+          writer.writeLine(`  logPrefix: "[${appName}]",`);
+          writer.writeLine(
+            `  plaintextReason: "no PLATFORM_KEK / SUBJECT_KEYS_DATABASE_URL / KUMIKO_BLIND_INDEX_KEY set — see .env.example",`,
+          );
+          writer.write("} as const");
         },
       },
     ],
   });
-
-  sf.addStatements((writer) => {
-    writer.write('if ("allowPlaintextPii" in kmsWiring) ').inlineBlock(() => {
-      writer.writeLine(
-        `console.warn(\`[${appName}] PII IS STORED IN PLAINTEXT — \${kmsWiring.allowPlaintextPii}\`);`,
-      );
-    });
+  sf.addVariableStatement({
+    declarationKind: VariableDeclarationKind.Const,
+    declarations: [
+      {
+        name: "kmsWiring",
+        initializer: (writer) => {
+          writer.write(`process.env["NODE_ENV"] === "production"`);
+          writer.newLine();
+          writer.write("  ? requireKmsWiring(process.env, kmsOpts)");
+          writer.newLine();
+          writer.write("  : resolveKmsWiring(process.env, kmsOpts)");
+        },
+      },
+    ],
   });
 
   sf.addStatements((writer) => {
@@ -697,11 +703,14 @@ JWT_SECRET=change-me-min-32-chars-change-me-min-32
 # Generate with: openssl rand -base64 32
 KUMIKO_SECRETS_MASTER_KEY_V1=
 
-# Subject-keys KMS for PII fields (user, tenant-invitation, fileRef). Unset by
-# default — bin/main.ts then boots with plaintext PII and a loud warning, fine
-# to get running locally. Set all three before a real deploy (crypto-shredding
-# needs it for GDPR erasure): PLATFORM_KEK generate with: openssl rand -base64 32
+# Subject-keys KMS for PII fields (user, tenant-invitation, fileRef). All-or-none.
+# Unset → local boot with plaintext PII + warning; NODE_ENV=production requires
+# the trio (requireKmsWiring). Generate PLATFORM_KEK / KUMIKO_BLIND_INDEX_KEY
+# with: openssl rand -base64 32. SUBJECT_KEYS_DATABASE_URL must be a dedicated
+# subject-keys cluster (not the app DB) — see kms-adapter.md.
 PLATFORM_KEK=
+# Separate Postgres instance for subject keys — never DATABASE_URL (retention
+# must outlive app-DB backups for crypto-shredding).
 SUBJECT_KEYS_DATABASE_URL=
 KUMIKO_BLIND_INDEX_KEY=
 

package/src/scaffold-demo-tasks.ts

@@ -215,7 +215,6 @@ export function renderDemoTasksIndex(): string {
 
 export function renderDemoSeedFile(): string {
   return `// Demo seed — a few tasks so \`bun dev\` shows a non-empty list.
-// Idempotent: skips when the tenant already has tasks (persistent dev DB).
 
 import type { SeedFn } from "@cosmicdrift/kumiko-dev-server";
 import { TestUsers } from "@cosmicdrift/kumiko-framework/stack";

package/src/schema-apply.ts

@@ -8,19 +8,16 @@
 
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import {
-  createDbConnection,
-  type DbConnection,
-  readRebuildMarker,
-  runMigrationsFromDir,
-} from "@cosmicdrift/kumiko-framework/db";
+import { createDbConnection, runMigrationsFromDir } from "@cosmicdrift/kumiko-framework/db";
 import { createRegistry, type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
 import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
-import { buildProjectionTableIndex } from "@cosmicdrift/kumiko-framework/migrations";
+import {
+  queueRebuildsFromMarkers,
+  runPendingRebuilds,
+} from "@cosmicdrift/kumiko-framework/migrations";
 import {
   createEventConsumerStateTable,
   createProjectionStateTable,
-  rebuildProjection,
 } from "@cosmicdrift/kumiko-framework/pipeline";
 import {
   type ComposeFeaturesOptions,
@@ -72,15 +69,34 @@ export async function runSchemaApply(opts: SchemaApplyOptions): Promise<number>
       console.log("");
     }
 
-    // Projection-Rebuild für Tabellen die in frisch applizierten Migrations
-    // geändert wurden (Marker NNNN_<name>.rebuild.json von `schema generate`).
-    // Ohne das blieben read_*-Projektionen nach einem Schema-Change stale.
-    const changedTables = new Set<string>();
-    for (const id of result.applied) {
-      for (const table of readRebuildMarker(migrationsDir, id)) changedTables.add(table);
+    // Projection rebuild: persistent queue instead of "only this run's
+    // result.applied" — otherwise a failed rebuild stays silently stuck
+    // forever, since the migration is already tracked applied and gets
+    // skipped on the next apply (#2464). queueRebuildsFromMarkers persists
+    // the marker tables BEFORE the rebuild; runPendingRebuilds unconditionally
+    // also picks up open entries from earlier, failed runs — not just the
+    // ones this run freshly applied.
+    const thisRunTables = await queueRebuildsFromMarkers(db, {
+      migrationsDir,
+      appliedIds: result.applied,
+    });
+    const registry = createRegistry(composeFeatures([...opts.features], opts));
+    const rebuildRun = await runPendingRebuilds(db, registry, { thisRunTables });
+    if (rebuildRun.rebuilt.length > 0) {
+      console.log(`  Rebuild ${rebuildRun.rebuilt.length} Projection(s)…`);
+      for (const r of rebuildRun.rebuilt) {
+        console.log(`    ↻ ${r.projection} (${r.eventsProcessed} events)`);
+      }
+      console.log("");
     }
-    if (changedTables.size > 0) {
-      await rebuildAffectedProjections(db, [...changedTables], opts);
+    if (rebuildRun.failed.length > 0) {
+      throw new Error(
+        `Projection rebuild failed for: ${rebuildRun.failed
+          .map((f) => `${f.projection} (${f.error})`)
+          .join(
+            "; ",
+          )}. Table(s) stay queued in kumiko_pending_rebuilds — retried on the next apply.`,
+      );
     }
 
     return 0;
@@ -92,39 +108,6 @@ export async function runSchemaApply(opts: SchemaApplyOptions): Promise<number>
   }
 }
 
-async function rebuildAffectedProjections(
-  db: DbConnection,
-  changedTables: readonly string[],
-  opts: SchemaApplyOptions,
-): Promise<void> {
-  const registry = createRegistry(composeFeatures([...opts.features], opts));
-  const tableToProjection = buildProjectionTableIndex(registry);
-
-  const projections = new Set<string>();
-  for (const table of changedTables) {
-    const name = tableToProjection.get(table);
-    if (name) {
-      projections.add(name);
-    } else {
-      // 522/3: a table in a .rebuild.json marker that no longer matches any
-      // registered projection would otherwise rebuild nothing and exit 0 —
-      // indistinguishable from "nothing needed a rebuild".
-      console.warn(
-        `  ⚠ Table "${table}" is in a rebuild marker but matches no registered projection — skipped.`,
-      );
-    }
-  }
-  // skip: no projections matched the changed tables, nothing to rebuild
-  if (projections.size === 0) return;
-
-  console.log(`  Rebuild ${projections.size} Projection(s)…`);
-  for (const name of projections) {
-    const r = await rebuildProjection(name, { db, registry });
-    console.log(`    ↻ ${name} (${r.eventsProcessed} events, ${r.durationMs}ms)`);
-  }
-  console.log("");
-}
-
 export async function runStandaloneSchemaCli(opts: SchemaApplyOptions): Promise<never> {
   const cmd = Bun.argv[2];
   const sub = Bun.argv[3];