@cosmicdrift/kumiko-framework 0.173.0 → 0.173.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.173.0",
+  "version": "0.173.1",
   "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>",
@@ -182,7 +182,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-types": "0.173.0",
+    "@cosmicdrift/kumiko-types": "0.173.1",
     "bullmq": "^5.76.7",
     "bun-types": "^1.3.13",
     "hono": "^4.12.27",
@@ -198,7 +198,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.173.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.173.1",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

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

@@ -200,6 +200,24 @@ CREATE TABLE IF NOT EXISTS "read_widgets_v2" ("id" uuid PRIMARY KEY);
     expect(cap.err.join("\n")).toContain("read_widgets");
   });
 
+  test("migration file missing a column its snapshot entry claims → column-drift hint, not unexpected-table", async () => {
+    writeSchemaFile(appCwd, "read_widgets", "note");
+    await runSchemaCli(["generate", "init"], appCwd, captureOut().out);
+    writeFileSync(
+      join(appCwd, "kumiko/migrations/0001_init.sql"),
+      `-- oops: hand-edited to drop the "note" column the snapshot still claims
+CREATE TABLE IF NOT EXISTS "read_widgets" ("id" uuid PRIMARY KEY);
+`,
+    );
+    const cap = captureOut();
+    const code = await runSchemaCli(["validate"], appCwd, cap.out);
+    expect(code).toBe(1);
+    const err = cap.err.join("\n");
+    expect(err).toContain("missing columns: note");
+    expect(err).toContain("Fix (missing-table/column-drift)");
+    expect(err).not.toContain("Fix (unexpected-table)");
+  });
+
   test("migration creates a table with no snapshot entry → unexpected-table hint points at r.storeTable, not hand-fix", async () => {
     writeSchemaFile(appCwd, "read_widgets");
     await runSchemaCli(["generate", "init"], appCwd, captureOut().out);

package/src/api/sse-broker.ts

@@ -25,9 +25,8 @@ export type SseBroker = {
 };
 
 export function createSseBroker(): SseBroker {
-  // ponytail: in-process only — publishAccessInvalidation does not fan out via
-  // Redis. Multi-replica deployments will not revoke SSE streams on other pods
-  // (security control is single-node). Upgrade: Redis pub/sub on userAccessChannel.
+  // Cross-replica fanout lives one level up: the SSE + access-invalidation
+  // consumers (system-hooks.ts) run delivery: "per-instance" (#1718).
   const channels = new Map<string, Map<string, SseClient>>();
   const accessInvalidationListeners = new Map<string, Set<() => void>>();
 

package/src/db/__tests__/migrate-runner.test.ts

@@ -38,6 +38,10 @@ describe("splitSqlStatements", () => {
     expect(splitSqlStatements("SELECT a/*x*/AS b;")).toEqual(["SELECT a AS b;"]);
   });
 
+  test("nested block comment also leaves a space at outer depth (#1599)", () => {
+    expect(splitSqlStatements("SELECT a/*x/*y*/z*/AS b;")).toEqual(["SELECT a AS b;"]);
+  });
+
   test("nested block comments close only at matching depth (Postgres)", () => {
     expect(splitSqlStatements("/* a /* b */ c */ SELECT 1;")).toEqual(["SELECT 1;"]);
   });

package/src/db/event-store-executor-write.ts

@@ -48,6 +48,40 @@ function isUnchangedValue(a: unknown, b: unknown): boolean {
   return JSON.stringify(a) === JSON.stringify(b);
 }
 
+type PreSaveFn = (
+  changes: Record<string, unknown>,
+  previous: Record<string, unknown>,
+  isNew: boolean,
+) => Promise<Record<string, unknown>>;
+
+// preSave runs before ownership checks: authorization must evaluate the row
+// as it will actually be persisted, including hook-derived fields
+// (kumiko-framework#1672). A throwing hook is an app-author bug (bad
+// business rule, not a framework fault) — map it to a clean writeFailure
+// instead of letting it propagate as an internal_error 500.
+async function runPreSave(
+  preSave: PreSaveFn | undefined,
+  changes: Record<string, unknown>,
+  previous: Record<string, unknown>,
+  isNew: boolean,
+  entityName: string,
+  action: "create" | "update",
+): Promise<{ readonly data: DbRow } | { readonly failure: ReturnType<typeof writeFailure> }> {
+  if (!preSave) return { data: changes as DbRow };
+  try {
+    return { data: (await preSave(changes, previous, isNew)) as DbRow };
+  } catch (e) {
+    return {
+      failure: writeFailure(
+        new UnprocessableError("presave_hook_failed", {
+          i18nKey: "errors.presaveHookFailed",
+          details: { entityName, action, message: e instanceof Error ? e.message : String(e) },
+        }),
+      ),
+    };
+  }
+}
+
 export function createWriteVerbs(
   ctx: ExecutorContext,
 ): Pick<EventStoreExecutor, "create" | "update" | "delete" | "forget" | "restore"> {
@@ -74,12 +108,16 @@ export function createWriteVerbs(
       const explicitId = typeof payload["id"] === "string" ? (payload["id"] as string) : undefined; // @cast-boundary engine-payload
       const aggregateId = explicitId ?? generateId();
       const { id: _id, ...payloadWithoutId } = payload;
-      // preSave runs before ownership checks: authorization must evaluate the
-      // row as it will actually be persisted, including hook-derived fields
-      // (kumiko-framework#1672).
-      const data = options?.preSave
-        ? await options.preSave(applyDefaults(payloadWithoutId), {}, true)
-        : applyDefaults(payloadWithoutId);
+      const preSaveResult = await runPreSave(
+        options?.preSave,
+        applyDefaults(payloadWithoutId),
+        {},
+        true,
+        entityName,
+        "create",
+      );
+      if ("failure" in preSaveResult) return preSaveResult.failure;
+      const data = preSaveResult.data;
 
       // H.2 — entity-level write-ownership on create. No oldRow exists, so
       // only the new row is checked. No Straddle concern for creates.
@@ -226,12 +264,16 @@ export function createWriteVerbs(
       const previous = await loadById(payload.id, db);
       if (!previous) return writeFailure(new NotFoundError(entityName, payload.id));
 
-      // preSave runs before ownership checks: authorization must evaluate the
-      // row as it will actually be persisted, including hook-derived fields
-      // (kumiko-framework#1672).
-      const changes = updateOptions?.preSave
-        ? await updateOptions.preSave(payload.changes, previous, false)
-        : payload.changes;
+      const preSaveResult = await runPreSave(
+        updateOptions?.preSave,
+        payload.changes,
+        previous,
+        false,
+        entityName,
+        "update",
+      );
+      if ("failure" in preSaveResult) return preSaveResult.failure;
+      const changes = preSaveResult.data;
 
       // H.2 — entity-level write-ownership on update. Load old row (already
       // done above), build post-change row via shallow merge. Straddle-safe

package/src/engine/__tests__/boot-validator.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import { z } from "zod";
 import type { SchemaTable } from "../../db/dialect";
 import { table, text } from "../../db/dialect";
@@ -590,6 +590,31 @@ describe("boot-validator", () => {
     expect(() => validateBoot(features)).not.toThrow();
   });
 
+  test("warns when a role is used by exactly one handler, reached through the real validateBoot wiring", () => {
+    const warnSpy = spyOn(console, "warn");
+    try {
+      const features = [
+        defineFeature("a", (r) => {
+          r.queryHandler("list", z.object({}), async () => [], {
+            access: { roles: ["OnlyHereRole"] },
+          });
+        }),
+      ];
+      validateBoot(features);
+      // Not toHaveBeenCalledTimes(1): this file's tests share the process-global
+      // console.warn and run with the default concurrency (bunfig.toml) — other
+      // concurrently-running tests' own "role used by one handler" warnings can
+      // land on this spy too. Assert the wiring fired at least once instead.
+      expect(
+        warnSpy.mock.calls.some((call) =>
+          (call[0] as string | undefined)?.includes("OnlyHereRole"),
+        ),
+      ).toBe(true);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
   test("throws when a stream handler has no access rule", () => {
     const features = [
       defineFeature("a", (r) => {
@@ -2953,6 +2978,67 @@ describe("boot-validator — config key backing × scope", () => {
     );
   });
 
+  // framework#1708: the same params-vs-update-mode check as entityList,
+  // extended to projectionList rowActions (#1680 covered entityList only).
+  test("projectionList rowAction: navigate with params to an entityEdit target + explicit entityId → Throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-projection",
+        type: "projectionList",
+        query: "shop:query:products",
+        columns: ["name"],
+        rowActions: [
+          {
+            kind: "navigate",
+            id: "open",
+            label: "actions.open",
+            screen: "product-edit",
+            entityId: "name",
+            params: { pick: ["name"] },
+          },
+        ],
+      });
+      r.screen({
+        id: "product-edit",
+        type: "entityEdit",
+        entity: "product",
+        layout: { sections: [{ columns: 1, fields: ["name"] }] },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(
+      /\(projectionList\) rowAction "open".*resolves to UPDATE mode \(explicit entityId "name"\)/,
+    );
+  });
+
+  test("projectionList rowAction: navigate with params to an entityEdit-create target (no entityId) → no throw", () => {
+    const feature = defineFeature("shop", (r) => {
+      r.entity("product", createEntity({ fields: { name: createTextField() } }));
+      r.screen({
+        id: "product-projection",
+        type: "projectionList",
+        query: "shop:query:products",
+        columns: ["name"],
+        rowActions: [
+          {
+            kind: "navigate",
+            id: "open",
+            label: "actions.open",
+            screen: "product-edit",
+            params: { pick: ["name"] },
+          },
+        ],
+      });
+      r.screen({
+        id: "product-edit",
+        type: "entityEdit",
+        entity: "product",
+        layout: { sections: [{ columns: 1, fields: ["name"] }] },
+      });
+    });
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
   test("navigate with params targeting a cross-entity entityEdit screen (no explicit entityId) → no throw", () => {
     // The issue's actual use case: a unit row navigates to "create contract"
     // pre-filled with unitId. Different entity + no explicit entityId → the

package/src/engine/__tests__/entity-presave-wiring.integration.test.ts

@@ -8,6 +8,7 @@ import { asRawClient } from "../../db/query";
 import { setupTestStack, type TestStack, TestUsers, unsafeCreateEntityTable } from "../../stack";
 import { defineFeature } from "../define-feature";
 import { createEntity, createTextField } from "../factories";
+import { from } from "../ownership";
 
 const contactEntity = createEntity({
   table: "presave_wiring_contacts",
@@ -15,6 +16,12 @@ const contactEntity = createEntity({
     firstName: createTextField({ required: true }),
     lastName: createTextField({ required: true }),
     displayName: createTextField(),
+    // authorId is never set by the client — only deriveAuthorId (a preSave
+    // hook) writes it. secretNote's ownership rule checks authorId, so
+    // create only succeeds if the hook ran BEFORE the field-ownership check
+    // (kumiko-framework#1672 — see also event-store-executor-write.ts).
+    authorId: createTextField(),
+    secretNote: createTextField({ access: { write: { User: from("user:id", "authorId") } } }),
   },
 });
 
@@ -30,6 +37,16 @@ const deriveDisplayName: import("../types").PreSaveHookFn = async (changes, ctx)
   return { ...changes, displayName: `${first ?? ""} ${last ?? ""}`.trim() };
 };
 
+const deriveAuthorId: import("../types").PreSaveHookFn = async (changes) => ({
+  ...changes,
+  authorId: TestUsers.user.id,
+});
+
+const THROWING_HOOK_MESSAGE = "business rule violated";
+const throwOnPreSave: import("../types").PreSaveHookFn = async () => {
+  throw new Error(THROWING_HOOK_MESSAGE);
+};
+
 const contactFeature = defineFeature("presave-wiring", (r) => {
   r.crud("contact", contactEntity, {
     write: { access: { roles: ["User"] } },
@@ -41,17 +58,34 @@ const contactFeature = defineFeature("presave-wiring", (r) => {
   // handlers, so both need their own target.
   r.hook("preSave", "contact:create", deriveDisplayName);
   r.hook("preSave", "contact:update", deriveDisplayName);
+  r.hook("preSave", "contact:create", deriveAuthorId);
+  r.hook("preSave", "contact:update", deriveAuthorId);
+});
+
+const throwingEntity = createEntity({
+  table: "presave_wiring_throwing",
+  fields: { name: createTextField({ required: true }) },
+});
+
+const throwingFeature = defineFeature("presave-wiring-throw", (r) => {
+  r.crud("thing", throwingEntity, {
+    write: { access: { roles: ["User"] } },
+    read: { access: { openToAll: true } },
+  });
+  r.hook("preSave", "thing:create", throwOnPreSave);
 });
 
 const CREATE = "presave-wiring:write:contact:create";
 const UPDATE = "presave-wiring:write:contact:update";
+const THROWING_CREATE = "presave-wiring-throw:write:thing:create";
 
 describe("preSave hooks — real dispatcher path (#1672)", () => {
   let stack: TestStack;
 
   beforeAll(async () => {
-    stack = await setupTestStack({ features: [contactFeature] });
+    stack = await setupTestStack({ features: [contactFeature, throwingFeature] });
     await unsafeCreateEntityTable(stack.db, contactEntity);
+    await unsafeCreateEntityTable(stack.db, throwingEntity);
   });
 
   afterAll(async () => {
@@ -94,4 +128,22 @@ describe("preSave hooks — real dispatcher path (#1672)", () => {
     expect(updated.data.displayName).toBe("Marc Kumiko");
     expect(seenIsNew).toEqual([true, false]);
   });
+
+  test("preSave runs before ownership checks: field authz sees the hook-derived owner id", async () => {
+    const res = await stack.http.write(
+      CREATE,
+      { firstName: "Marc", lastName: "Ristone", secretNote: "psst" },
+      TestUsers.user,
+    );
+    expect(res.status).toBe(200);
+    const { data } = (await res.json()) as { data: { data: { secretNote: string } } };
+    expect(data.data.secretNote).toBe("psst");
+  });
+
+  test("a throwing preSave hook maps to a clean writeFailure, not a 500", async () => {
+    const res = await stack.http.write(THROWING_CREATE, { name: "x" }, TestUsers.user);
+    expect(res.status).toBe(422);
+    const body = (await res.json()) as { error?: { details?: { message?: string } } };
+    expect(body.error?.details?.message).toBe(THROWING_HOOK_MESSAGE);
+  });
 });

package/src/engine/__tests__/schema-builder.test.ts

@@ -449,6 +449,23 @@ describe("buildInsertSchema", () => {
     expect(schema.safeParse({ locale: "en" }).success).toBe(true);
     expect(schema.safeParse({ locale: "xx" }).success).toBe(false);
   });
+
+  // #1712: pin omitted-key + explicit undefined — ZodPipe/optin path for defaults
+  test("optional select with default applies when key omitted or undefined", () => {
+    const entity = createEntity({
+      table: "Test",
+      fields: {
+        locale: createSelectField({ options: ["de", "en", "fr"] as const, default: "de" }),
+      },
+    });
+    const schema = buildInsertSchema(entity);
+    const omitted = schema.safeParse({});
+    expect(omitted.success).toBe(true);
+    if (omitted.success) expect(omitted.data["locale"]).toBe("de");
+    const undef = schema.safeParse({ locale: undefined });
+    expect(undef.success).toBe(true);
+    if (undef.success) expect(undef.data["locale"]).toBe("de");
+  });
 });
 
 // --- Update schema (all partial) ---

package/src/engine/__tests__/store-table.test.ts

@@ -84,6 +84,21 @@ describe("r.storeTable — declaration", () => {
     ).toThrow(/the "read_" prefix is reserved/);
   });
 
+  // #1598: registration guard — plain literal meta bypasses defineUnmanagedTable
+  test("r.storeTable rejects a plain literal meta with reserved read_ prefix", () => {
+    const literalMeta = {
+      tableName: "read_rt_probe",
+      columns: [{ name: "id", pgType: "text" as const, notNull: true, primaryKey: true }],
+      source: "unmanaged" as const,
+      indexes: [],
+    };
+    expect(() =>
+      defineFeature("probe", (r) => {
+        r.storeTable(literalMeta, { reason: "test" });
+      }),
+    ).toThrow(/the "read_" prefix is reserved/);
+  });
+
   test("accepts valid registration and stores meta + reason", () => {
     const feature = defineFeature("probe", (r) => {
       r.storeTable(probeMeta, {

package/src/engine/boot-validator/screens.ts

@@ -22,6 +22,47 @@ import type {
   ToolbarAction,
 } from "../types/screen";
 
+// Tier 2.7e navigate rowAction → target-screen params validity. Shared by
+// entityList and projectionList (framework#1708) — projectionList has no
+// `screen.entity`, so there's no same-entity row["id"] auto-fill case: any
+// entityEdit target without an explicit entityId reaches create there.
+function validateRowActionNavigateParams(
+  featureName: string,
+  screenId: string,
+  screenType: "entityList" | "projectionList",
+  screenEntity: string | undefined,
+  action: RowAction,
+  target: { readonly featureName: string; readonly screen: ScreenDefinition } | undefined,
+): void {
+  // skip: not a navigate-with-params action — nothing to validate here.
+  if (action.kind !== "navigate" || action.params === undefined) return;
+  // skip: unresolvable/custom target already reported (or exempt) elsewhere.
+  if (target === undefined || target.screen.type === "custom") return;
+
+  const isEntityEditUpdate =
+    target.screen.type === "entityEdit" &&
+    (action.entityId !== undefined ||
+      (screenEntity !== undefined && target.screen.entity === screenEntity));
+  if (
+    (target.screen.type !== "actionForm" && target.screen.type !== "entityEdit") ||
+    isEntityEditUpdate
+  ) {
+    const reason = isEntityEditUpdate
+      ? `resolves to UPDATE mode (${
+          action.entityId !== undefined
+            ? `explicit entityId "${action.entityId}"`
+            : `same entity "${screenEntity}" auto-fills row["id"]`
+        })`
+      : `screen type "${target.screen.type}"`;
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (${screenType}) rowAction "${action.id}" ` +
+        `sets params on navigate-target "${action.screen}" which ${reason} — only actionForm ` +
+        `and entityEdit-create targets read URL search params as initial values. Remove the ` +
+        `params extractor or retarget to an actionForm / cross-entity entityEdit-create screen.`,
+    );
+  }
+}
+
 // --- Screen validation ---
 //
 // For every r.screen() declaration check what's locally knowable at boot:
@@ -169,6 +210,28 @@ export function validateScreens(
       for (const col of screen.columns) {
         validateColumnRendererForm(feature.name, screenId, normalizeListColumn(col));
       }
+      if (screen.rowActions !== undefined) {
+        for (const action of screen.rowActions) {
+          if (action.kind === "navigate") {
+            const candidateQn = qualifyEntityName(feature.name, "screen", action.screen);
+            if (!allScreenQns.has(candidateQn) && !navTargetShortIds.has(action.screen)) {
+              throw new Error(
+                `[Feature ${feature.name}] Screen "${screenId}" (projectionList) rowAction "${action.id}" ` +
+                  `navigate-target "${action.screen}" does not resolve to a registered screen in any feature.`,
+              );
+            }
+            const target = screensByShortId.get(action.screen)?.[0];
+            validateRowActionNavigateParams(
+              feature.name,
+              screenId,
+              "projectionList",
+              undefined,
+              action,
+              target,
+            );
+          }
+        }
+      }
       continue;
     }
 
@@ -590,33 +653,14 @@ export function validateScreens(
             // explicit entityId) a same-entity target gets row["id"] auto-
             // injected — only a cross-entity target with no explicit
             // entityId reaches create.
-            if (
-              action.params !== undefined &&
-              target !== undefined &&
-              target.screen.type !== "custom"
-            ) {
-              const isEntityEditUpdate =
-                target.screen.type === "entityEdit" &&
-                (action.entityId !== undefined || target.screen.entity === screen.entity);
-              if (
-                (target.screen.type !== "actionForm" && target.screen.type !== "entityEdit") ||
-                isEntityEditUpdate
-              ) {
-                const reason = isEntityEditUpdate
-                  ? `resolves to UPDATE mode (${
-                      action.entityId !== undefined
-                        ? `explicit entityId "${action.entityId}"`
-                        : `same entity "${screen.entity}" auto-fills row["id"]`
-                    })`
-                  : `screen type "${target.screen.type}"`;
-                throw new Error(
-                  `[Feature ${feature.name}] Screen "${screenId}" (entityList) rowAction "${action.id}" ` +
-                    `sets params on navigate-target "${action.screen}" which ${reason} — only actionForm ` +
-                    `and entityEdit-create targets read URL search params as initial values. Remove the ` +
-                    `params extractor or retarget to an actionForm / cross-entity entityEdit-create screen.`,
-                );
-              }
-            }
+            validateRowActionNavigateParams(
+              feature.name,
+              screenId,
+              "entityList",
+              screen.entity,
+              action,
+              target,
+            );
           } else {
             if (!allWriteHandlerQns.has(action.handler)) {
               throw new Error(

package/src/entrypoint/__tests__/split-deploy.integration.test.ts

@@ -32,6 +32,11 @@ const splitFeature = defineFeature("split", (r) => {
   });
 });
 
+// Consumed by the worker's OWN eventDispatcher after worker.start() — proves
+// the write→afterCommit→MSP chain runs end-to-end inside the worker lane,
+// not just that the write itself lands in the event store (framework#1720).
+const consumedNotes: string[] = [];
+
 const workerWriteFeature = defineFeature("workerWrite", (r) => {
   const noted = r.defineEvent("noted", z.object({ note: z.string() }), { version: 1 });
   r.writeHandler(
@@ -48,8 +53,24 @@ const workerWriteFeature = defineFeature("workerWrite", (r) => {
     },
     { access: { openToAll: true } },
   );
+  r.multiStreamProjection({
+    name: "consume-notes",
+    apply: {
+      [noted.name]: async (event) => {
+        consumedNotes.push((event.payload as { note: string }).note);
+      },
+    },
+  });
 });
 
+async function waitForCondition(check: () => boolean, timeoutMs = 5000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!check()) {
+    if (Date.now() > deadline) throw new Error("waitForCondition: timed out");
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}
+
 const JWT = "split-deploy-test-secret-must-be-32-chars!!";
 
 // Per-test queue-name with a random suffix. Date.now() alone collided
@@ -132,6 +153,8 @@ describe("entrypoint factories", () => {
       queueNamePrefix: uniquePrefix("split-dispatch"),
     });
 
+    consumedNotes.length = 0;
+    await worker.start();
     try {
       const result = await worker.dispatcher.write(
         "worker-write:write:note",
@@ -147,6 +170,11 @@ describe("entrypoint factories", () => {
       expect((rows[0] as { payload: { note: string } }).payload.note).toBe(
         "written from the worker",
       );
+
+      // The worker's own eventDispatcher (started above) picks the event
+      // back up and runs the MSP — proves the afterCommit/MSP chain works
+      // inside the worker lane, not just that the write itself succeeded.
+      await waitForCondition(() => consumedNotes.includes("written from the worker"));
     } finally {
       await worker.stop();
     }

package/src/jobs/__tests__/scheduler-id.test.ts

@@ -9,7 +9,7 @@ describe("schedulerIdForJobName", () => {
     const id = schedulerIdForJobName("publicstatus:job:uptime-probe");
     expect(id).toBe("scheduler-publicstatus-job-uptime-probe");
     expect(id.includes(":")).toBe(false);
-    expect(`repeat:${id}:1784992080000`.split(":").length).toBeLessThan(5);
+    expect(`repeat:${id}:1784992080000`.split(":").length).toBe(3);
   });
 
   test("still collapses dotted QNs", () => {