@cosmicdrift/kumiko-framework 0.269.2 → 0.270.0

package/src/pipeline/__tests__/dispatcher.test.ts

@@ -33,7 +33,7 @@ const echoFeature = defineFeature("echo", (r) => {
       items: [],
       search: query.payload.search,
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.streamHandler(
@@ -137,7 +137,7 @@ describe("dispatcher.write", () => {
         z.object({ name: z.string() }),
         async (event) => ({ isSuccess: true, data: { name: event.payload.name } }),
         {
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           rateLimit: { per: "ip+handler", limit: 3, windowSeconds: 60 },
         },
       );
@@ -168,7 +168,7 @@ describe("dispatcher.write", () => {
         z.object({ name: z.string() }),
         async (event) => ({ isSuccess: true, data: { name: event.payload.name } }),
         {
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           rateLimit: { per: "user", limit: 3, windowSeconds: 60 },
         },
       );
@@ -428,7 +428,7 @@ describe("dispatcher.stream", () => {
             yield { i };
           }
         },
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const dispatcher = createDispatcher(createRegistry([nestedFeature]), {
@@ -466,7 +466,7 @@ describe("dispatcher.stream", () => {
             throw new Error("close-boom");
           }
         },
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const dispatcher = createDispatcher(createRegistry([closeFailFeature]), {
@@ -500,7 +500,7 @@ describe("dispatcher.stream", () => {
           yield { i: 0 };
           yield { i: 1 };
         },
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const dispatcher = createDispatcher(createRegistry([feature]), {
@@ -536,7 +536,7 @@ describe("dispatcher.stream", () => {
           yield { i: 1 };
           yield { i: 2 };
         },
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const dispatcher = createDispatcher(createRegistry([feature]), {
@@ -571,7 +571,7 @@ describe("dispatcher.query postQuery hooks", () => {
     // pass on entity-existence makes such a hook register silently + never run.
     const feature = defineFeature("dash", (r) => {
       r.queryHandler("dashboard", z.object({}), async () => ({ count: 1 }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook("postQuery", "dashboard", async ({ entityName, rows }) => {
         expect(entityName).toBeUndefined();
@@ -590,7 +590,7 @@ describe("dispatcher.query postQuery hooks", () => {
     // [...null]). The hook here returns the row unchanged so the shape survives.
     const feature = defineFeature("nullrows", (r) => {
       r.queryHandler("dashboard", z.object({}), async () => ({ rows: null, nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook("postQuery", "dashboard", async ({ rows }) => ({ rows }));
     });
@@ -603,7 +603,7 @@ describe("dispatcher.query postQuery hooks", () => {
   test("single-object postQuery hook returning ≠1 row throws", async () => {
     const feature = defineFeature("multi", (r) => {
       r.queryHandler("dashboard", z.object({}), async () => ({ count: 1 }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook("postQuery", "dashboard", async ({ rows }) => ({ rows: [...rows, ...rows] }));
     });
@@ -708,7 +708,7 @@ describe("dispatcher feature-gate", () => {
         }),
       );
       r.queryHandler("widget:list", z.object({}).passthrough(), async () => ({ items: [] }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.writeHandler(
         "widget:create",
@@ -728,7 +728,7 @@ describe("dispatcher feature-gate", () => {
             i++;
           }
         },
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
   }
@@ -900,7 +900,7 @@ describe("dispatcher feature-gate", () => {
         "check",
         z.object({}).passthrough(),
         async (_event, ctx) => ({ enabled: await ctx.hasFeature("toggled") }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const registry = createRegistry([toggled(), probe]);
@@ -940,7 +940,7 @@ describe("dispatcher feature-gate", () => {
         "check",
         z.object({}).passthrough(),
         async (_event, ctx) => ({ enabled: await ctx.hasFeature("premium-companion") }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const registry = createRegistry([probe]);
@@ -1027,7 +1027,7 @@ describe("dispatcher context.geoTzProvider (680/1)", () => {
             longitude: query.payload.longitude,
           }),
         }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
     const registry = createRegistry([geoFeature]);

package/src/pipeline/__tests__/lifecycle-pipeline.test.ts

@@ -24,7 +24,7 @@ function makeRegistry(hooks?: { preSave?: PreSaveHookFn[]; postSave?: PostSaveHo
     );
     // Dummy handler so hook targets resolve (boot validation requires it)
     r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
-      access: { openToAll: true },
+      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
     });
     if (hooks?.preSave) {
       for (const h of hooks.preSave) r.hook("preSave", "user", h);
@@ -296,7 +296,7 @@ describe("runPostSave phase routing", () => {
     const feature = defineFeature("phases", (r) => {
       r.entity("user", createEntity({ table: "Users", fields: {} }));
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook(
         "postSave",
@@ -325,7 +325,7 @@ describe("runPostSave phase routing", () => {
     const feature = defineFeature("phases", (r) => {
       r.entity("user", createEntity({ table: "Users", fields: {} }));
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook(
         "postSave",
@@ -351,7 +351,7 @@ describe("runPostSave phase routing", () => {
       const feature = defineFeature("phases", (r) => {
         r.entity("user", createEntity({ table: "Users", fields: {} }));
         r.writeHandler("user", z.object({}), async () => ({ isSuccess: true, data: null }), {
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         });
         r.hook("postSave", "user", async () => {
           throw new Error("afterCommit-boom");
@@ -378,7 +378,7 @@ describe("runPostSave phase routing", () => {
     const feature = defineFeature("phases", (r) => {
       r.entity("user", createEntity({ table: "Users", fields: {} }));
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
     });
     const registry = createRegistry([feature]);
@@ -439,7 +439,7 @@ describe("Sprint 8a: per-tenant entity-hook filter", () => {
         "widget:create",
         z.object({ name: z.string() }),
         async () => ({ isSuccess: true as const, data: null }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
     });
 
@@ -570,7 +570,7 @@ describe("runPreDelete", () => {
         }),
       );
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook("preDelete", "user", async () => {
         calls.push("handler");
@@ -606,7 +606,7 @@ describe("runPreDelete", () => {
         }),
       );
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook("preDelete", "user", async () => {
         throw new Error("blocked-delete");
@@ -652,7 +652,7 @@ describe("runPostDelete", () => {
         }),
       );
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook("postDelete", "user", async () => {
         calls.push("feature");
@@ -685,7 +685,7 @@ describe("runPostDelete", () => {
         }),
       );
       r.writeHandler("user", z.object({}), async () => ({ isSuccess: true as const, data: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.hook(
         "postDelete",

package/src/pipeline/__tests__/load-aggregate-query.integration.test.ts

@@ -133,7 +133,7 @@ const asOfFeature = defineFeature("asoftest", (r) => {
       }
       return state;
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 

package/src/pipeline/__tests__/post-query-hook.integration.test.ts

@@ -58,7 +58,7 @@ const postQueryFeature = defineFeature("postquerytest", (r) => {
       ],
       nextCursor: null,
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   // Handler-keyed: fires only for widget:list
@@ -91,13 +91,13 @@ const duplicateRowHook: PostQueryHookFn = async ({ rows }) => ({ rows: [...rows,
 const singleObjectFeature = defineFeature("singleobjtest", (r) => {
   const gadget = r.entity("gadget", gadgetEntity);
   r.queryHandler("gadget:get", z.object({}), async () => ({ id: "g1", name: "Gadget" }), {
-    access: { openToAll: true },
+    access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
   });
   r.hook("postQuery", { allOf: gadget }, dropRowHook);
 
   const gizmo = r.entity("gizmo", gizmoEntity);
   r.queryHandler("gizmo:get", z.object({}), async () => ({ id: "z1", name: "Gizmo" }), {
-    access: { openToAll: true },
+    access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
   });
   r.hook("postQuery", { allOf: gizmo }, duplicateRowHook);
 });

package/src/pipeline/__tests__/query-projection.integration.test.ts

@@ -92,7 +92,7 @@ const qpFeature = defineFeature("qp", (r) => {
     "widget:list-tenant",
     z.object({}),
     async (_query, ctx) => ctx.queryProjection("qp:projection:widget-count-tenant"),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.queryHandler(
@@ -102,14 +102,14 @@ const qpFeature = defineFeature("qp", (r) => {
       ctx.queryProjection("qp:projection:widget-audit", {
         unsafeAllTenants: query.payload.unsafeAllTenants ?? false,
       }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.queryHandler(
     "widget:list-ghost",
     z.object({}),
     async (_query, ctx) => ctx.queryProjection("qp:projection:does-not-exist"),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 

package/src/scripts/codemod/migrate-open-to-all.ts

@@ -0,0 +1,248 @@
+#!/usr/bin/env bun
+// migrate-open-to-all — rewrites deprecated `openToAll: true` to the required
+// `{ reason }` form in test files, and reports every remaining non-test site
+// for a human to pick a reason (fw#2858).
+//
+// Usage:
+//   bun scripts/codemod/migrate-open-to-all.ts [--dry-run] [--test-reason "<text>"] <path...>
+
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import {
+  Node,
+  type ObjectLiteralExpression,
+  Project,
+  type PropertyAssignment,
+  SyntaxKind,
+} from "ts-morph";
+
+const DEFAULT_TEST_REASON = "test handler callable by any signed-in test user";
+
+export interface Rewrite {
+  readonly file: string;
+  readonly line: number;
+  readonly before: string;
+  readonly after: string;
+}
+
+export interface ManualSite {
+  readonly file: string;
+  readonly line: number;
+  readonly handlerName?: string;
+  readonly description?: string;
+}
+
+export interface MigrateOpenToAllResult {
+  readonly output: string;
+  readonly rewrites: Rewrite[];
+  readonly manual: ManualSite[];
+}
+
+export interface MigrateOpenToAllOptions {
+  readonly testReason: string;
+}
+
+function isTestFile(fileName: string): boolean {
+  return /(^|\/)__tests__\//.test(fileName) || /\.test\.(ts|tsx)$/.test(fileName);
+}
+
+function isOpenToAllTrueAssignment(node: Node): node is PropertyAssignment {
+  if (!Node.isPropertyAssignment(node)) return false;
+  if (node.getName() !== "openToAll") return false;
+  return node.getInitializer()?.getKind() === SyntaxKind.TrueKeyword;
+}
+
+function readStringLiteralProperty(obj: ObjectLiteralExpression, name: string): string | undefined {
+  const prop = obj.getProperty(name);
+  if (!prop || !Node.isPropertyAssignment(prop)) return undefined;
+  const init = prop.getInitializer();
+  return init && Node.isStringLiteral(init) ? init.getLiteralValue() : undefined;
+}
+
+function enclosingObjectLiterals(node: Node): ObjectLiteralExpression[] {
+  const result: ObjectLiteralExpression[] = [];
+  let current: Node | undefined = node.getParent();
+  while (current) {
+    if (Node.isObjectLiteralExpression(current)) result.push(current);
+    current = current.getParent();
+  }
+  return result;
+}
+
+// Best-effort human-triage hint (not the rewrite's source of truth): derive a handler name/description from the enclosing object literal, or the enclosing call's first string-literal argument for the positional form.
+function deriveHandlerContext(assignment: PropertyAssignment): {
+  readonly handlerName?: string;
+  readonly description?: string;
+} {
+  let handlerName: string | undefined;
+  let description: string | undefined;
+  for (const obj of enclosingObjectLiterals(assignment)) {
+    if (handlerName === undefined) handlerName = readStringLiteralProperty(obj, "name");
+    if (description === undefined) description = readStringLiteralProperty(obj, "description");
+    if (handlerName !== undefined && description !== undefined) break;
+  }
+  if (handlerName === undefined) {
+    const call = assignment.getFirstAncestorByKind(SyntaxKind.CallExpression);
+    const firstArg = call?.getArguments()[0];
+    if (firstArg && Node.isStringLiteral(firstArg)) handlerName = firstArg.getLiteralValue();
+  }
+  return {
+    ...(handlerName !== undefined && { handlerName }),
+    ...(description !== undefined && { description }),
+  };
+}
+
+export function migrateOpenToAllSource(
+  source: string,
+  fileName: string,
+  opts: MigrateOpenToAllOptions,
+): MigrateOpenToAllResult {
+  const project = new Project({ useInMemoryFileSystem: true, skipFileDependencyResolution: true });
+  const sourceFile = project.createSourceFile(fileName, source);
+  const testFile = isTestFile(fileName);
+
+  const targets = sourceFile
+    .getDescendantsOfKind(SyntaxKind.PropertyAssignment)
+    .filter(isOpenToAllTrueAssignment);
+
+  const rewrites: Rewrite[] = [];
+  const manual: ManualSite[] = [];
+
+  for (const assignment of targets) {
+    if (assignment.wasForgotten()) continue;
+    const line = assignment.getStartLineNumber();
+
+    if (testFile) {
+      const before = assignment.getText();
+      const after = `openToAll: { reason: ${JSON.stringify(opts.testReason)} }`;
+      assignment.replaceWithText(after);
+      rewrites.push({ file: fileName, line, before, after });
+      continue;
+    }
+
+    manual.push({ file: fileName, line, ...deriveHandlerContext(assignment) });
+  }
+
+  return { output: sourceFile.getFullText(), rewrites, manual };
+}
+
+class CliError extends Error {}
+
+interface CliOptions {
+  readonly dryRun: boolean;
+  readonly testReason: string;
+  readonly paths: string[];
+}
+
+function parseArgs(argv: string[]): CliOptions {
+  let dryRun = false;
+  let testReason = DEFAULT_TEST_REASON;
+  const paths: string[] = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (arg === "--test-reason") {
+      const value = argv[++i];
+      if (!value) throw new CliError("--test-reason requires a value");
+      testReason = value;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new CliError(`unknown flag: ${arg}`);
+    paths.push(arg);
+  }
+
+  if (paths.length === 0) throw new CliError("at least one path is required");
+  return { dryRun, testReason, paths };
+}
+
+function isMigratableFile(name: string): boolean {
+  return /\.(ts|tsx)$/.test(name);
+}
+
+function walkDir(dir: string, out: string[]): void {
+  for (const name of readdirSync(dir)) {
+    if (name === "node_modules") continue;
+    const full = join(dir, name);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      walkDir(full, out);
+      continue;
+    }
+    if (isMigratableFile(name)) out.push(full);
+  }
+}
+
+function collectFiles(paths: string[]): string[] {
+  const files: string[] = [];
+  for (const p of paths) {
+    const abs = resolve(p);
+    const stat = statSync(abs);
+    if (stat.isDirectory()) walkDir(abs, files);
+    else if (isMigratableFile(abs)) files.push(abs);
+  }
+  return files;
+}
+
+async function main(): Promise<void> {
+  let options: CliOptions;
+  try {
+    options = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    if (err instanceof CliError) {
+      console.error(`[migrate-open-to-all] ${err.message}`);
+      process.exit(2);
+    }
+    throw err;
+  }
+
+  const files = collectFiles(options.paths);
+  const allManual: ManualSite[] = [];
+  let filesChanged = 0;
+  let totalRewrites = 0;
+
+  for (const file of files) {
+    const before = readFileSync(file, "utf8");
+    if (!before.includes("openToAll")) continue;
+    const result = migrateOpenToAllSource(before, file, { testReason: options.testReason });
+    allManual.push(...result.manual);
+
+    if (result.rewrites.length === 0) continue;
+    filesChanged += 1;
+    totalRewrites += result.rewrites.length;
+
+    if (options.dryRun) {
+      console.log(`\n=== ${file} (${result.rewrites.length} rewrite(s)) ===`);
+      for (const r of result.rewrites) {
+        console.log(`${file}:${r.line}`);
+        console.log(`- ${r.before}`);
+        console.log(`+ ${r.after}`);
+      }
+    } else {
+      writeFileSync(file, result.output);
+    }
+  }
+
+  console.log(
+    `\n[migrate-open-to-all] ${options.dryRun ? "would change" : "changed"} ${filesChanged} file(s); ` +
+      `rewrites: ${totalRewrites}`,
+  );
+
+  if (allManual.length > 0) {
+    console.log(`\n[migrate-open-to-all] manual review needed (${allManual.length}):`);
+    for (const m of allManual) {
+      console.log(
+        `${m.file}:${m.line}  ${m.handlerName ?? "<unknown>"}  ${m.description ?? "<no description>"}`,
+      );
+    }
+  }
+
+  process.exit(0);
+}
+
+if (import.meta.main) {
+  await main();
+}

package/src/secrets/__tests__/contains-secret.test.ts

@@ -54,7 +54,7 @@ declare const aSecret: Secret<string>;
 defineQueryHandler({
   name: "t:query:leak",
   schema,
-  access: { openToAll: true },
+  access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
   handler: async () => ({ apiKey: aSecret }),
 });
 
@@ -65,7 +65,7 @@ function genericResponseHandler<K extends string>(kind: K) {
   return defineQueryHandler({
     name: "t:query:generic",
     schema,
-    access: { openToAll: true },
+    access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
     handler: async () => ({ kind, ok: true }) as { kind: K; ok: boolean },
   });
 }
@@ -83,7 +83,7 @@ declare const leakingUnion: { ok: true } | { apiKey: Secret<string> };
 defineQueryHandler({
   name: "t:query:union-leak",
   schema,
-  access: { openToAll: true },
+  access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
   handler: async () => leakingUnion,
 });
 
@@ -91,7 +91,7 @@ declare const cleanUnion: { ok: true } | { id: string };
 defineQueryHandler({
   name: "t:query:union-clean",
   schema,
-  access: { openToAll: true },
+  access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
   handler: async () => cleanUnion,
 });
 
@@ -100,7 +100,7 @@ describe("R6 ContainsSecret", () => {
     const def = defineQueryHandler({
       name: "t:query:clean",
       schema,
-      access: { openToAll: true },
+      access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       handler: async () => ({ ok: true, value: createSecret("x").reveal() }),
     });
     expect(def.name).toBe("t:query:clean");

package/src/stack/__tests__/request-helper.integration.test.ts

@@ -20,7 +20,7 @@ const pingFeature = defineFeature("reqhelp", (r) => {
       isSuccess: true as const,
       data: { note: event.payload.note, userId: event.user.id },
     }),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.writeHandler(
@@ -28,7 +28,7 @@ const pingFeature = defineFeature("reqhelp", (r) => {
     z.object({}),
     async () =>
       writeFailure(new UnprocessableError("reqhelp-boom", { i18nKey: "errors.unprocessable" })),
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 
   r.queryHandler(
@@ -40,7 +40,7 @@ const pingFeature = defineFeature("reqhelp", (r) => {
       }
       return { id: query.payload.id, ok: true };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
 });
 

package/src/stack/__tests__/setup-test-stack-jobs.integration.test.ts

@@ -29,7 +29,7 @@ const manualDispatchFeature = defineFeature("manualdispatch", (r) => {
       await jobRunner.dispatch("manualdispatch:job:record", { note: event.payload.note });
       return { isSuccess: true as const, data: { id: 1, note: event.payload.note } };
     },
-    { access: { openToAll: true } },
+    { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
   );
   r.job("record", { trigger: { manual: true }, runIn: "worker" }, async (payload) => {
     jobRuns.push({ name: "manualdispatch:job:record", payload });

package/src/testing/__tests__/e2e-generator.test.ts

@@ -34,7 +34,11 @@ function createTasksFeature() {
   return defineFeature("tasks", (r) => {
     r.systemScope();
     r.entity("task", taskEntity);
-    r.writeHandler(defineEntityCreateHandler("task", taskEntity, { access: { openToAll: true } }));
+    r.writeHandler(
+      defineEntityCreateHandler("task", taskEntity, {
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+      }),
+    );
     r.screen({
       id: "task-list",
       type: "entityList",
@@ -105,7 +109,11 @@ describe("generateE2ESpec", () => {
     const feature = defineFeature("events", (r) => {
       r.systemScope();
       r.entity("event", entity);
-      r.writeHandler(defineEntityCreateHandler("event", entity, { access: { openToAll: true } }));
+      r.writeHandler(
+        defineEntityCreateHandler("event", entity, {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        }),
+      );
       r.screen({
         id: "event-edit",
         type: "entityEdit",
@@ -165,7 +173,9 @@ describe("generateE2ESpec", () => {
       r.systemScope();
       r.entity("task", taskEntity);
       r.writeHandler(
-        defineEntityCreateHandler("task", taskEntity, { access: { openToAll: true } }),
+        defineEntityCreateHandler("task", taskEntity, {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        }),
       );
       r.screen({
         id: "edit",
@@ -201,7 +211,9 @@ describe("generateE2ESpec", () => {
       r.systemScope();
       r.entity("contact", contactEntity);
       r.writeHandler(
-        defineEntityCreateHandler("contact", contactEntity, { access: { openToAll: true } }),
+        defineEntityCreateHandler("contact", contactEntity, {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        }),
       );
       r.screen({
         id: "list",
@@ -225,7 +237,9 @@ describe("generateE2ESpec", () => {
       r.systemScope();
       r.entity("task", taskEntity);
       r.writeHandler(
-        defineEntityCreateHandler("task", taskEntity, { access: { openToAll: true } }),
+        defineEntityCreateHandler("task", taskEntity, {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        }),
       );
       r.screen({ id: "list", type: "entityList", entity: "task", columns: ["title"] });
       r.screen({