@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

package/src/pipeline/__tests__/archive-stream.integration.test.ts

@@ -1,299 +0,0 @@
-// C2 — archiveStream (Marten-aligned).
-//
-// Marten's session.Events.ArchiveStream(id): the stream becomes read-only,
-// loads return an empty slice, further appends throw. Restoring un-archives.
-// Kumiko carries this as a sparse kumiko_archived_streams table so active
-// streams never pay for extra metadata writes.
-
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
-import * as z from "zod";
-import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { buildEntityTable } from "../../db/table-builder";
-import { createEntity, createTextField, defineFeature } from "../../engine";
-import {
-  ArchivedStreamError,
-  isStreamArchived,
-  loadAggregate as loadAggregateRaw,
-} from "../../event-store";
-import {
-  resetEventStore,
-  setupTestStack,
-  type TestStack,
-  TestUsers,
-  unsafeCreateEntityTable,
-} from "../../stack";
-
-const itemEntity = createEntity({
-  table: "read_arch_items",
-  fields: { label: createTextField({ personal: false, reason: "test_fixture", required: true }) },
-});
-const itemTable = buildEntityTable("arch-item", itemEntity);
-
-const archFeature = defineFeature("archtest", (r) => {
-  r.entity("arch-item", itemEntity);
-
-  const labelChanged = r.defineEvent("label-changed", z.object({ label: z.string() }), {
-    piiFields: "none",
-  });
-
-  const executor = createEventStoreExecutor(itemTable, itemEntity, {
-    entityName: "arch-item",
-  });
-
-  r.writeHandler(
-    "item:create",
-    z.object({ label: z.string() }),
-    async (event, ctx) => executor.create(event.payload, event.user, ctx.db),
-    { access: { roles: ["Admin"] } },
-  );
-
-  r.writeHandler(
-    "item:relabel",
-    z.object({ id: z.uuid(), label: z.string() }),
-    async (event, ctx) => {
-      await ctx.unsafeAppendEvent({
-        aggregateId: event.payload.id,
-        aggregateType: "arch-item",
-        type: labelChanged.name,
-        payload: { label: event.payload.label },
-      });
-      return { isSuccess: true as const, data: { id: event.payload.id } };
-    },
-    { access: { roles: ["Admin"] } },
-  );
-
-  r.writeHandler(
-    "item:archive",
-    z.object({ id: z.uuid(), reason: z.string().optional() }),
-    async (event, ctx) => {
-      await ctx.archiveStream(event.payload.id, {
-        aggregateType: "arch-item",
-        reason: event.payload.reason,
-      });
-      return { isSuccess: true as const, data: { id: event.payload.id } };
-    },
-    { access: { roles: ["Admin"] } },
-  );
-
-  r.writeHandler(
-    "item:restore",
-    z.object({ id: z.uuid() }),
-    async (event, ctx) => {
-      await ctx.restoreStream(event.payload.id);
-      return { isSuccess: true as const, data: { id: event.payload.id } };
-    },
-    { access: { roles: ["Admin"] } },
-  );
-
-  r.writeHandler(
-    "item:update",
-    z.object({ id: z.uuid(), label: z.string() }),
-    async (event, ctx) =>
-      executor.update(
-        { id: event.payload.id, changes: { label: event.payload.label } },
-        event.user,
-        ctx.db,
-        { skipOptimisticLock: true },
-      ),
-    { access: { roles: ["Admin"] } },
-  );
-
-  r.writeHandler(
-    "item:delete",
-    z.object({ id: z.uuid() }),
-    async (event, ctx) => executor.delete({ id: event.payload.id }, event.user, ctx.db),
-    // arch-item has no softDelete — a hard delete needs agent.risk: "high"
-    // to pass the irreversible-operation gate.
-    { access: { roles: ["Admin"] }, agent: { risk: "high" } },
-  );
-
-  r.queryHandler(
-    "item:events",
-    z.object({ id: z.uuid() }),
-    async (query, ctx) => ctx.loadAggregate(query.payload.id),
-    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
-  );
-
-  r.queryHandler(
-    "item:is-archived",
-    z.object({ id: z.uuid() }),
-    async (query, ctx) => ctx.isStreamArchived(query.payload.id),
-    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
-  );
-});
-
-let stack: TestStack;
-const admin = TestUsers.admin;
-
-beforeAll(async () => {
-  stack = await setupTestStack({ features: [archFeature], systemHooks: [] });
-  await unsafeCreateEntityTable(stack.db, itemEntity, "arch-item");
-});
-
-afterAll(async () => {
-  await stack.cleanup();
-});
-
-afterEach(async () => {
-  await resetEventStore(stack, ["read_arch_items"]);
-});
-
-describe("archiveStream — Marten ArchiveStream equivalent", () => {
-  test("archived stream returns empty from ctx.loadAggregate", async () => {
-    const { id } = await stack.http.writeOk<{ id: string }>(
-      "archtest:write:item:create",
-      { label: "alpha" },
-      admin,
-    );
-    await stack.http.writeOk("archtest:write:item:relabel", { id, label: "beta" }, admin);
-
-    // Pre-archive: two events visible.
-    const before = await stack.http.queryOk<unknown[]>("archtest:query:item:events", { id }, admin);
-    expect(before.length).toBe(2);
-
-    await stack.http.writeOk("archtest:write:item:archive", { id, reason: "cleanup" }, admin);
-
-    // Post-archive: empty slice by default.
-    const after = await stack.http.queryOk<unknown[]>("archtest:query:item:events", { id }, admin);
-    expect(after).toEqual([]);
-
-    // Archive flag is visible.
-    const archived = await stack.http.queryOk<boolean>(
-      "archtest:query:item:is-archived",
-      { id },
-      admin,
-    );
-    expect(archived).toBe(true);
-
-    // Low-level loader with includeArchived surfaces the events for ops.
-    const raw = await loadAggregateRaw(stack.db, id, admin.tenantId, {
-      includeArchived: true,
-    });
-    expect(raw).toHaveLength(2);
-  });
-
-  test("appendEvent on an archived stream is rejected with ArchivedStreamError", async () => {
-    const { id } = await stack.http.writeOk<{ id: string }>(
-      "archtest:write:item:create",
-      { label: "before-archive" },
-      admin,
-    );
-    await stack.http.writeOk("archtest:write:item:archive", { id }, admin);
-
-    // Writing through the handler surfaces the ArchivedStreamError as a
-    // 500 (InternalError path) — the framework treats archive violations
-    // as logic errors, not user-input errors. The detail message is
-    // masked in the HTTP response (don't leak internals), so the proof
-    // is structural: 500 status + no event landed on disk.
-    const res = await stack.http.write(
-      "archtest:write:item:relabel",
-      { id, label: "too-late" },
-      admin,
-    );
-    expect(res.status).toBe(500);
-
-    // Sanity: the failed write did not land on disk.
-    const raw = await loadAggregateRaw(stack.db, id, admin.tenantId, {
-      includeArchived: true,
-    });
-    const types = raw.map((e) => e.type);
-    expect(types).toContain("arch-item.created");
-    expect(types).not.toContain("archtest:event:label-changed");
-  });
-
-  test("restoreStream reopens the stream for writes and reads", async () => {
-    const { id } = await stack.http.writeOk<{ id: string }>(
-      "archtest:write:item:create",
-      { label: "phoenix" },
-      admin,
-    );
-    await stack.http.writeOk("archtest:write:item:archive", { id }, admin);
-    expect(await isStreamArchived(stack.db, admin.tenantId, id)).toBe(true);
-
-    await stack.http.writeOk("archtest:write:item:restore", { id }, admin);
-    expect(await isStreamArchived(stack.db, admin.tenantId, id)).toBe(false);
-
-    // Writes go through again AND keep the correct version lineage —
-    // the original "created" event is at version 1, so the post-restore
-    // relabel lands at version 2.
-    await stack.http.writeOk("archtest:write:item:relabel", { id, label: "reborn" }, admin);
-    const events = await loadAggregateRaw(stack.db, id, admin.tenantId);
-    expect(events.map((e) => e.version)).toEqual([1, 2]);
-  });
-
-  test("archive is idempotent — repeated archive calls do not throw", async () => {
-    const { id } = await stack.http.writeOk<{ id: string }>(
-      "archtest:write:item:create",
-      { label: "repeat" },
-      admin,
-    );
-
-    await stack.http.writeOk("archtest:write:item:archive", { id, reason: "first" }, admin);
-    await stack.http.writeOk("archtest:write:item:archive", { id, reason: "second" }, admin);
-
-    const archived = await isStreamArchived(stack.db, admin.tenantId, id);
-    expect(archived).toBe(true);
-  });
-
-  test("ArchivedStreamError carries aggregateId + tenantId", () => {
-    const err = new ArchivedStreamError(admin.tenantId, "agg-1");
-    expect(err.aggregateId).toBe("agg-1");
-    expect(err.tenantId).toBe(admin.tenantId);
-    expect(err.name).toBe("ArchivedStreamError");
-  });
-
-  // The CRUD executor appends via append() + getStreamVersion(), neither of
-  // which consults the archive flag. Without the executor-level guard a
-  // PATCH/DELETE would silently land an event on an archived stream — the
-  // read-only contract honoured by ctx.appendEvent would not extend to
-  // entity-CRUD writes. These prove the guard closes that gap on both paths.
-  describe("CRUD writes honour the archive guard", () => {
-    test("executor.update on an archived stream is rejected, no event lands", async () => {
-      const { id } = await stack.http.writeOk<{ id: string }>(
-        "archtest:write:item:create",
-        { label: "before-archive" },
-        admin,
-      );
-      await stack.http.writeOk("archtest:write:item:archive", { id }, admin);
-
-      const res = await stack.http.write(
-        "archtest:write:item:update",
-        { id, label: "too-late" },
-        admin,
-      );
-      expect(res.status).toBe(500);
-
-      const raw = await loadAggregateRaw(stack.db, id, admin.tenantId, { includeArchived: true });
-      expect(raw.map((e) => e.type)).not.toContain("arch-item.updated");
-    });
-
-    test("executor.delete on an archived stream is rejected, no event lands", async () => {
-      const { id } = await stack.http.writeOk<{ id: string }>(
-        "archtest:write:item:create",
-        { label: "keep-me" },
-        admin,
-      );
-      await stack.http.writeOk("archtest:write:item:archive", { id }, admin);
-
-      const res = await stack.http.write("archtest:write:item:delete", { id }, admin);
-      expect(res.status).toBe(500);
-
-      const raw = await loadAggregateRaw(stack.db, id, admin.tenantId, { includeArchived: true });
-      expect(raw.map((e) => e.type)).not.toContain("arch-item.deleted");
-    });
-
-    test("restoreStream re-opens the stream for CRUD updates", async () => {
-      const { id } = await stack.http.writeOk<{ id: string }>(
-        "archtest:write:item:create",
-        { label: "v1" },
-        admin,
-      );
-      await stack.http.writeOk("archtest:write:item:archive", { id }, admin);
-      await stack.http.writeOk("archtest:write:item:restore", { id }, admin);
-
-      await stack.http.writeOk("archtest:write:item:update", { id, label: "v2" }, admin);
-      const raw = await loadAggregateRaw(stack.db, id, admin.tenantId);
-      expect(raw.map((e) => e.type)).toEqual(["arch-item.created", "arch-item.updated"]);
-    });
-  });
-});

package/src/pipeline/__tests__/auth-claims-resolver.test.ts

@@ -1,279 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import type { AuthClaimsContext, AuthClaimsHookDef, SessionUser } from "../../engine/types";
-import type { Logger } from "../../logging/types";
-import { resolveAuthClaims } from "../auth-claims-resolver";
-
-type TestLogger = {
-  readonly log: Logger;
-  readonly warn: ReturnType<typeof mock>;
-};
-
-function makeTestLogger(): TestLogger {
-  const warn = mock();
-  const info = mock();
-  const error = mock();
-  const debug = mock();
-  const logger: Logger = {
-    warn,
-    info,
-    error,
-    debug,
-    child: () => logger,
-  };
-  return { log: logger, warn };
-}
-
-const testUser: SessionUser = {
-  id: "11111111-0000-4000-8000-000000000001",
-  tenantId: "22222222-0000-4000-8000-000000000001",
-  roles: ["User"],
-};
-
-// The resolver doesn't actually USE the AuthClaimsContext — it passes it
-// through to each hook. For unit tests we only need the shape; we don't
-// construct a real TenantDb.
-const stubContext: AuthClaimsContext = {
-  db: {} as AuthClaimsContext["db"],
-  queryAs: async () => {
-    throw new Error("queryAs not implemented in stub");
-  },
-};
-
-function hooks(...entries: AuthClaimsHookDef[]): readonly AuthClaimsHookDef[] {
-  return entries;
-}
-
-describe("resolveAuthClaims — empty", () => {
-  test("zero hooks registered → empty record, contextFactory not called", async () => {
-    const factory = mock();
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: [],
-      contextFactory: factory,
-    });
-    expect(result).toEqual({});
-    expect(factory).not.toHaveBeenCalled();
-  });
-});
-
-describe("resolveAuthClaims — single hook", () => {
-  test("feature's keys get prefixed with <featureName>:", async () => {
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks({
-        featureName: "drivers",
-        fn: async () => ({ teamId: "t-1", regionId: "r-7" }),
-      }),
-      contextFactory: () => stubContext,
-    });
-    expect(result).toEqual({
-      "drivers:teamId": "t-1",
-      "drivers:regionId": "r-7",
-    });
-  });
-
-  test("receives the user and context handed in", async () => {
-    const fn = mock(async () => ({}));
-    const factory = mock(() => stubContext);
-    await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks({ featureName: "any", fn }),
-      contextFactory: factory,
-    });
-    expect(fn).toHaveBeenCalledWith(testUser, stubContext);
-    expect(factory).toHaveBeenCalledWith(testUser);
-    expect(factory).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("resolveAuthClaims — multiple hooks", () => {
-  test("two features run in parallel and both contribute claims", async () => {
-    const ordering: string[] = [];
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks(
-        {
-          featureName: "drivers",
-          fn: async () => {
-            ordering.push("drivers");
-            return { teamId: "t-1" };
-          },
-        },
-        {
-          featureName: "billing",
-          fn: async () => {
-            ordering.push("billing");
-            return { plan: "pro" };
-          },
-        },
-      ),
-      contextFactory: () => stubContext,
-    });
-    expect(result).toEqual({
-      "drivers:teamId": "t-1",
-      "billing:plan": "pro",
-    });
-    // Promise.allSettled fires both; order of push() can vary but both must run.
-    expect(ordering.sort()).toEqual(["billing", "drivers"]);
-  });
-
-  test("auto-prefix eliminates cross-feature collisions on the SAME inner key", async () => {
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks(
-        { featureName: "drivers", fn: async () => ({ teamId: "t-drivers" }) },
-        { featureName: "billing", fn: async () => ({ teamId: "t-billing" }) },
-      ),
-      contextFactory: () => stubContext,
-    });
-    expect(result).toEqual({
-      "drivers:teamId": "t-drivers",
-      "billing:teamId": "t-billing",
-    });
-  });
-});
-
-describe("resolveAuthClaims — same-feature duplicate hooks", () => {
-  test("last-wins within one feature", async () => {
-    // Two r.authClaims() calls in the same feature both return `plan`.
-    // The second registration wins (matches the JWT-layer spread semantics).
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks(
-        { featureName: "billing", fn: async () => ({ plan: "free" }) },
-        { featureName: "billing", fn: async () => ({ plan: "enterprise" }) },
-      ),
-      contextFactory: () => stubContext,
-    });
-    expect(result["billing:plan"]).toBe("enterprise");
-  });
-});
-
-describe("resolveAuthClaims — error policy (best-effort)", () => {
-  test("one hook throws → its feature contributes nothing, others unaffected", async () => {
-    const { log, warn } = makeTestLogger();
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks(
-        {
-          featureName: "broken",
-          fn: async () => {
-            throw new Error("db blew up");
-          },
-        },
-        {
-          featureName: "healthy",
-          fn: async () => ({ teamId: "t-1" }),
-        },
-      ),
-      contextFactory: () => stubContext,
-      log,
-    });
-    // healthy feature's claims make it into the record; broken feature's do not.
-    expect(result).toEqual({ "healthy:teamId": "t-1" });
-    // The warn should mention the feature name so ops can pinpoint the hook.
-    expect(warn).toHaveBeenCalledTimes(1);
-    const [warnMsg, warnData] = warn.mock.calls[0] ?? [];
-    expect(String(warnMsg)).toContain("authClaims");
-    expect(warnData).toMatchObject({ featureName: "broken" });
-  });
-
-  test("every hook throws → result is still an object (login does not fail)", async () => {
-    const { log } = makeTestLogger();
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks(
-        {
-          featureName: "a",
-          fn: async () => {
-            throw new Error("x");
-          },
-        },
-        {
-          featureName: "b",
-          fn: async () => {
-            throw new Error("y");
-          },
-        },
-      ),
-      contextFactory: () => stubContext,
-      log,
-    });
-    expect(result).toEqual({});
-  });
-});
-
-describe("resolveAuthClaims — reserved separator guard", () => {
-  test("a key containing ':' is dropped with a warning (keeps prefix owned by framework)", async () => {
-    const { log, warn } = makeTestLogger();
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks({
-        featureName: "smart",
-        // A feature that tries to sneak in its own prefix would bypass
-        // auto-prefix intent — so we reject such keys rather than double-prefix.
-        fn: async () => ({ "evil:teamId": "nope", okKey: "yes" }),
-      }),
-      contextFactory: () => stubContext,
-      log,
-    });
-    expect(result).toEqual({ "smart:okKey": "yes" });
-    expect(warn).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("resolveAuthClaims — declaredKeys drift warning", () => {
-  test("hook returns a key NOT in declaredKeys → warn, but claim still lands in JWT", async () => {
-    const { log, warn } = makeTestLogger();
-    const result = await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks({
-        featureName: "drivers",
-        // Feature declared `teamId` but the hook also returns `rouge` — the
-        // resolver flags it (typo/rename protection) but still merges it in,
-        // honoring best-effort.
-        declaredKeys: new Set(["teamId"]),
-        fn: async () => ({ teamId: "t-1", rouge: "x" }),
-      }),
-      contextFactory: () => stubContext,
-      log,
-    });
-    expect(result).toEqual({
-      "drivers:teamId": "t-1",
-      "drivers:rouge": "x",
-    });
-    expect(warn).toHaveBeenCalledTimes(1);
-    const [, data] = warn.mock.calls[0] ?? [];
-    expect(data).toMatchObject({ featureName: "drivers", undeclaredKey: "rouge" });
-  });
-
-  test("declaredKeys undefined → never warn, backwards-compat for ad-hoc hooks", async () => {
-    const { log, warn } = makeTestLogger();
-    await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks({
-        featureName: "legacy",
-        // No declaredKeys on this hook — legacy hooks don't opt in.
-        fn: async () => ({ anything: 1, else: 2 }),
-      }),
-      contextFactory: () => stubContext,
-      log,
-    });
-    expect(warn).not.toHaveBeenCalled();
-  });
-
-  test("all returned keys declared → silent", async () => {
-    const { log, warn } = makeTestLogger();
-    await resolveAuthClaims({
-      user: testUser,
-      hooks: hooks({
-        featureName: "drivers",
-        declaredKeys: new Set(["teamId", "regionId"]),
-        fn: async () => ({ teamId: "t-1", regionId: 7 }),
-      }),
-      contextFactory: () => stubContext,
-      log,
-    });
-    expect(warn).not.toHaveBeenCalled();
-  });
-});

package/src/pipeline/__tests__/blind-index-rebuild-guard.integration.test.ts

@@ -1,94 +0,0 @@
-// projection-rebuild aborts instead of silently NULLing an already-populated
-// blind-index column when this process has no blind-index key configured
-// (fw#3091) — see assertNoBlindIndexLoss in db/queries/shadow-swap.ts.
-
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { resetBlindIndexKeyForTests } from "@cosmicdrift/kumiko-framework/testing";
-import { computeBlindIndex, configureBlindIndexKey, decodeBlindIndexKey } from "../../crypto";
-import { createEventStoreExecutor } from "../../db/event-store-executor";
-import { asRawClient } from "../../db/query";
-import { buildEntityTable } from "../../db/table-builder";
-import { createTenantDb, type TenantDb } from "../../db/tenant-db";
-import { createEntity, createRegistry, createTextField, defineFeature } from "../../engine";
-import { createProjectionStateTable, rebuildProjection } from "../../pipeline";
-import { createTestDb, type TestDb, TestUsers, unsafeCreateEntityTable } from "../../stack";
-
-const TEST_KEY_B64 = Buffer.alloc(32, 9).toString("base64");
-const TEST_KEY = decodeBlindIndexKey(TEST_KEY_B64);
-
-const personEntity = createEntity({
-  table: "read_bidx_guard_persons",
-  fields: {
-    email: createTextField({ required: true, personal: "self", find: "exact" }),
-  },
-});
-const personFeature = defineFeature("bidxguardtest", (r) => {
-  r.entity("person", personEntity);
-});
-const personTable = buildEntityTable("person", personEntity);
-const implicitName = "bidxguardtest:projection:person-entity";
-
-const admin = TestUsers.admin;
-let testDb: TestDb;
-let tdb: TenantDb;
-const registry = createRegistry([personFeature]);
-const crud = createEventStoreExecutor(personTable, personEntity, { entityName: "person" });
-
-beforeAll(async () => {
-  testDb = await createTestDb();
-  await unsafeCreateEntityTable(testDb.db, personEntity, "person");
-  await createProjectionStateTable(testDb.db);
-  tdb = createTenantDb(testDb.db, admin.tenantId);
-});
-
-afterAll(async () => {
-  await testDb.cleanup();
-});
-
-beforeEach(async () => {
-  await asRawClient(testDb.db).unsafe(
-    `TRUNCATE kumiko_events, read_bidx_guard_persons, kumiko_projections RESTART IDENTITY CASCADE`,
-  );
-  configureBlindIndexKey(TEST_KEY_B64);
-});
-
-afterEach(() => {
-  resetBlindIndexKeyForTests();
-});
-
-async function rawRow(id: string): Promise<Record<string, unknown>> {
-  const rows = await asRawClient(testDb.db).unsafe<Record<string, unknown>>(
-    `SELECT * FROM read_bidx_guard_persons WHERE id = $1`,
-    [id],
-  );
-  const row = rows[0];
-  if (!row) throw new Error(`no row for ${id}`);
-  return row;
-}
-
-describe("projection-rebuild — blind-index loss guard (fw#3091)", () => {
-  test("populated bidx column + no key in this process → rebuild throws, live table untouched", async () => {
-    const created = await crud.create({ email: "marc@example.com" }, admin, tdb);
-    if (!created.isSuccess) throw new Error("create failed");
-    const before = await rawRow(String(created.data.id));
-    expect(before["email_bidx"]).toBe(computeBlindIndex(TEST_KEY, "marc@example.com"));
-
-    resetBlindIndexKeyForTests();
-    await expect(rebuildProjection(implicitName, { db: testDb.db, registry })).rejects.toThrow(
-      /KUMIKO_BLIND_INDEX_KEY/,
-    );
-
-    const after = await rawRow(String(created.data.id));
-    expect(after).toEqual(before);
-  });
-
-  test("populated bidx column + key configured → rebuild succeeds, bidx recomputed", async () => {
-    const created = await crud.create({ email: "marc@example.com" }, admin, tdb);
-    if (!created.isSuccess) throw new Error("create failed");
-
-    await rebuildProjection(implicitName, { db: testDb.db, registry });
-
-    const after = await rawRow(String(created.data.id));
-    expect(after["email_bidx"]).toBe(computeBlindIndex(TEST_KEY, "marc@example.com"));
-  });
-});