@cosmicdrift/kumiko-framework 0.260.0 → 0.261.0

package/src/engine/__tests__/build-app-schema.test.ts

@@ -891,6 +891,7 @@ describe("buildAppSchema", () => {
           cursor: z.string().optional(),
         }),
         async () => ({ rows: [], nextCursor: null }),
+        { access: { openToAll: true } },
       );
       r.screen({
         id: "schedule-list",
@@ -909,7 +910,9 @@ describe("buildAppSchema", () => {
 
   test("projectionList: a query schema without search/sort/cursor derives no capability", () => {
     const f = defineFeature("ledger", (r) => {
-      r.queryHandler("schedule:list", z.object({}), async () => ({ rows: [], nextCursor: null }));
+      r.queryHandler("schedule:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
+        access: { openToAll: true },
+      });
       r.screen({
         id: "schedule-list",
         type: "projectionList",
@@ -931,6 +934,7 @@ describe("buildAppSchema", () => {
         "schedule:list",
         z.union([z.object({ a: z.string() }), z.object({ b: z.string() })]),
         async () => ({ rows: [], nextCursor: null }),
+        { access: { openToAll: true } },
       );
       r.screen({
         id: "schedule-list",
@@ -952,10 +956,15 @@ describe("buildAppSchema", () => {
 
   test("projectionList: author-written searchable:false survives even when the schema accepts search", () => {
     const f = defineFeature("ledger", (r) => {
-      r.queryHandler("schedule:list", z.object({ search: z.string().optional() }), async () => ({
-        rows: [],
-        nextCursor: null,
-      }));
+      r.queryHandler(
+        "schedule:list",
+        z.object({ search: z.string().optional() }),
+        async () => ({
+          rows: [],
+          nextCursor: null,
+        }),
+        { access: { openToAll: true } },
+      );
       r.screen({
         id: "schedule-list",
         type: "projectionList",

package/src/engine/__tests__/engine.test.ts

@@ -15,6 +15,7 @@ import {
   createTextField,
 } from "../factories";
 import { createApp, createRegistry, defineFeature } from "../index";
+import type { AccessRule } from "../types";
 import { buildMinimalCtx } from "./_pipeline-test-utils";
 
 // --- defineFeature ---
@@ -930,6 +931,15 @@ describe("hasAccess", () => {
     const user = createTestUser({ roles: [] });
     expect(hasAccess(user, { openToAll: true })).toBe(true);
   });
+
+  test.each([{ openToAll: false }, { openToAll: {} }])(
+    "malformed openToAll %p denies access instead of crashing",
+    (access) => {
+      const user = createTestUser({ roles: ["Employee"] });
+      // @cast-boundary test — simulates JSON/Designer input that doesn't match the static union
+      expect(hasAccess(user, access as unknown as AccessRule)).toBe(false);
+    },
+  );
 });
 
 // --- Entity with softDelete ---

package/src/engine/__tests__/entity-handlers.test.ts

@@ -37,29 +37,35 @@ const noteEntitySoftDelete = createEntity({
   softDelete: true,
 });
 
+const adminAccess = { access: { roles: ["Admin"] } } as const;
+
 describe("defineEntityWriteHandler", () => {
   test("throws when name has no colon", () => {
-    expect(() => defineEntityWriteHandler("note", noteEntity)).toThrow(/<entity>:<verb>/);
+    expect(() => defineEntityWriteHandler("note", noteEntity, adminAccess)).toThrow(
+      /<entity>:<verb>/,
+    );
   });
 
   test("throws when entity part is empty", () => {
-    expect(() => defineEntityWriteHandler(":create", noteEntity)).toThrow(
+    expect(() => defineEntityWriteHandler(":create", noteEntity, adminAccess)).toThrow(
       /missing the entity part/,
     );
   });
 
   test("throws when verb is unknown", () => {
-    expect(() => defineEntityWriteHandler("note:archive", noteEntity)).toThrow(
+    expect(() => defineEntityWriteHandler("note:archive", noteEntity, adminAccess)).toThrow(
       /Unknown verb "archive"/,
     );
   });
 
   test("throws when restore is requested on an entity without softDelete", () => {
-    expect(() => defineEntityRestoreHandler("note", noteEntity)).toThrow(/restore is only valid/);
+    expect(() => defineEntityRestoreHandler("note", noteEntity, adminAccess)).toThrow(
+      /restore is only valid/,
+    );
   });
 
   test("create: handler def carries name, schema, handler", () => {
-    const def = defineEntityCreateHandler("note", noteEntity);
+    const def = defineEntityCreateHandler("note", noteEntity, adminAccess);
     expect(def.name).toBe("note:create");
     expect(typeof def.handler).toBe("function");
     expect(def.schema.safeParse({ title: "x" }).success).toBe(true);
@@ -67,7 +73,7 @@ describe("defineEntityWriteHandler", () => {
   });
 
   test("update: schema requires id + version + changes", () => {
-    const def = defineEntityUpdateHandler("note", noteEntity);
+    const def = defineEntityUpdateHandler("note", noteEntity, adminAccess);
     expect(
       def.schema.safeParse({ id: VALID_UUID, version: 1, changes: { title: "x" } }).success,
     ).toBe(true);
@@ -76,13 +82,13 @@ describe("defineEntityWriteHandler", () => {
   });
 
   test("delete: schema requires only id", () => {
-    const def = defineEntityDeleteHandler("note", noteEntity);
+    const def = defineEntityDeleteHandler("note", noteEntity, adminAccess);
     expect(def.schema.safeParse({ id: VALID_UUID }).success).toBe(true);
     expect(def.schema.safeParse({}).success).toBe(false);
   });
 
   test("restore: schema requires only id (with softDelete)", () => {
-    const def = defineEntityRestoreHandler("note", noteEntitySoftDelete);
+    const def = defineEntityRestoreHandler("note", noteEntitySoftDelete, adminAccess);
     expect(def.schema.safeParse({ id: VALID_UUID }).success).toBe(true);
     expect(def.schema.safeParse({}).success).toBe(false);
   });
@@ -94,21 +100,21 @@ describe("defineEntityWriteHandler", () => {
     expect(def.access).toEqual({ roles: ["Admin"] });
   });
 
-  test("omitting access leaves the handler def's access unset", () => {
-    const def = defineEntityCreateHandler("note", noteEntity);
-    expect(def.access).toBeUndefined();
+  test("access is now a required option — omitting it is a type error", () => {
+    // @ts-expect-error access is required since fw#2855 — no implicit openToAll.
+    expect(() => defineEntityCreateHandler("note", noteEntity)).toThrow();
   });
 });
 
 describe("defineEntityQueryHandler", () => {
   test("throws when verb is unknown (write verbs are not allowed here)", () => {
-    expect(() => defineEntityQueryHandler("note:create", noteEntity)).toThrow(
+    expect(() => defineEntityQueryHandler("note:create", noteEntity, adminAccess)).toThrow(
       /Unknown verb "create"/,
     );
   });
 
   test("list: schema accepts the standard pagination/search/sort params", () => {
-    const def = defineEntityListHandler("note", noteEntity);
+    const def = defineEntityListHandler("note", noteEntity, adminAccess);
     expect(def.schema.safeParse({}).success).toBe(true);
     expect(
       def.schema.safeParse({
@@ -123,7 +129,7 @@ describe("defineEntityQueryHandler", () => {
   });
 
   test("list: schema is the exported entityListSchema, not a private copy", () => {
-    const def = defineEntityListHandler("note", noteEntity);
+    const def = defineEntityListHandler("note", noteEntity, adminAccess);
     expect(def.schema).toBe(entityListSchema);
     // money-horse#293: a consumer copy silently dropped these fields when it
     // drifted from the handler's actual schema — assert they still round-trip.
@@ -136,7 +142,7 @@ describe("defineEntityQueryHandler", () => {
   });
 
   test("detail: schema requires id", () => {
-    const def = defineEntityDetailHandler("note", noteEntity);
+    const def = defineEntityDetailHandler("note", noteEntity, adminAccess);
     expect(def.schema.safeParse({ id: VALID_UUID }).success).toBe(true);
     expect(def.schema.safeParse({}).success).toBe(false);
   });
@@ -186,6 +192,7 @@ describe("defineProjectionQueryHandler", () => {
     const def = defineProjectionQueryHandler(
       "revenue:list",
       "showcase:projection:customer-revenue",
+      { access: { openToAll: true } },
     );
     const fakeRows = [{ customer: "a", totalCents: 100 }];
     const ctx = {
@@ -208,7 +215,7 @@ describe("defineProjectionQueryHandler", () => {
     const def = defineProjectionQueryHandler(
       "revenue:list",
       "showcase:projection:customer-revenue",
-      { unsafeAllTenants: true },
+      { access: { openToAll: true }, unsafeAllTenants: true },
     );
     const ctx = { queryProjection: mock().mockResolvedValue([]) };
     await def.handler(
@@ -222,12 +229,11 @@ describe("defineProjectionQueryHandler", () => {
     });
   });
 
-  test("omitting access leaves the handler def's access unset", () => {
-    const def = defineProjectionQueryHandler(
-      "revenue:list",
-      "showcase:projection:customer-revenue",
-    );
-    expect(def.access).toBeUndefined();
+  test("access is now a required option — omitting it is a type error", () => {
+    expect(() =>
+      // @ts-expect-error access is required since fw#2855 — no implicit openToAll.
+      defineProjectionQueryHandler("revenue:list", "showcase:projection:customer-revenue"),
+    ).toThrow();
   });
 });
 
@@ -247,22 +253,24 @@ describe("Verb-specific entity-handler factories", () => {
   });
 
   test("defineEntityUpdateHandler produziert <entity>:update", () => {
-    const def = defineEntityUpdateHandler("note", noteEntity);
+    const def = defineEntityUpdateHandler("note", noteEntity, adminAccess);
     expect(def.name).toBe("note:update");
   });
 
   test("defineEntityDeleteHandler produziert <entity>:delete", () => {
-    const def = defineEntityDeleteHandler("note", noteEntity);
+    const def = defineEntityDeleteHandler("note", noteEntity, adminAccess);
     expect(def.name).toBe("note:delete");
   });
 
   test("defineEntityRestoreHandler produziert <entity>:restore (auf softDelete-Entity)", () => {
-    const def = defineEntityRestoreHandler("note", noteEntitySoftDelete);
+    const def = defineEntityRestoreHandler("note", noteEntitySoftDelete, adminAccess);
     expect(def.name).toBe("note:restore");
   });
 
   test("defineEntityRestoreHandler ohne softDelete → throw (Runtime-Guard bleibt)", () => {
-    expect(() => defineEntityRestoreHandler("note", noteEntity)).toThrow(/softDelete: true/);
+    expect(() => defineEntityRestoreHandler("note", noteEntity, adminAccess)).toThrow(
+      /softDelete: true/,
+    );
   });
 
   test("defineEntityListHandler produziert <entity>:list", () => {
@@ -274,7 +282,7 @@ describe("Verb-specific entity-handler factories", () => {
   });
 
   test("defineEntityDetailHandler produziert <entity>:detail", () => {
-    const def = defineEntityDetailHandler("note", noteEntity);
+    const def = defineEntityDetailHandler("note", noteEntity, adminAccess);
     expect(def.name).toBe("note:detail");
   });
 
@@ -284,8 +292,8 @@ describe("Verb-specific entity-handler factories", () => {
     // defineEntityCreateHandler("note", ...) sein. Wir vergleichen
     // hier die Schema-Identitäten + Handler-Namen; Behavior-Tests des
     // Executors leben in event-store-executor.integration.ts.
-    const newApi = defineEntityCreateHandler("note", noteEntity);
-    const legacyApi = defineEntityCreateHandler("note", noteEntity);
+    const newApi = defineEntityCreateHandler("note", noteEntity, adminAccess);
+    const legacyApi = defineEntityCreateHandler("note", noteEntity, adminAccess);
     expect(newApi.name).toBe(legacyApi.name);
     expect(typeof newApi.handler).toBe("function");
     expect(typeof legacyApi.handler).toBe("function");
@@ -337,17 +345,16 @@ describe("registerEntityCrud", () => {
   test("verbs.delete: false skips delete handler", () => {
     const { r, writes } = createCrudRegistrarMock();
     registerEntityCrud(r, "note", noteEntity, {
+      write: adminAccess,
+      read: adminAccess,
       verbs: { delete: false },
     });
     expect(writes.map((w) => w.name)).toEqual(["note:create", "note:update"]);
   });
 
-  test("no options → handlers have no access (no implicit openToAll)", () => {
-    const { r, writes, queries } = createCrudRegistrarMock();
-    registerEntityCrud(r, "note", noteEntity);
-    for (const def of [...writes, ...queries]) {
-      expect(def.access).toBeUndefined();
-    }
+  test("no options → registration throws (no implicit openToAll)", () => {
+    const { r } = createCrudRegistrarMock();
+    expect(() => registerEntityCrud(r, "note", noteEntity)).toThrow(/no access rule resolved/);
   });
 
   test("restore verb on entity without softDelete throws", () => {
@@ -361,6 +368,7 @@ describe("registerEntityCrud", () => {
     const { r, entities, writes } = createCrudRegistrarMock();
     r.entity("note", noteEntity);
     registerEntityCrud(r, "note", noteEntity, {
+      write: adminAccess,
       registerEntity: false,
       verbs: { update: false, delete: false, restore: false, list: false, detail: false },
     });
@@ -370,6 +378,8 @@ describe("registerEntityCrud", () => {
   test("descriptions: per-verb text lands on that verb only, and drives agent exposure", () => {
     const { r, writes, queries } = createCrudRegistrarMock();
     registerEntityCrud(r, "note", noteEntity, {
+      write: adminAccess,
+      read: adminAccess,
       descriptions: {
         create: "Files a new note.",
         list: "Lists notes newest first.",
@@ -398,7 +408,7 @@ describe("registerEntityCrud", () => {
   test("descriptions: per-verb entry wins over the write/read fallback", () => {
     const { r, writes } = createCrudRegistrarMock();
     registerEntityCrud(r, "note", noteEntity, {
-      write: { description: "Shared write text." },
+      write: { access: { roles: ["Admin"] }, description: "Shared write text." },
       descriptions: { create: "Files a new note." },
       verbs: { list: false, detail: false },
     });
@@ -409,10 +419,12 @@ describe("registerEntityCrud", () => {
 
   test("agent hints on the per-handler options raise the resolved risk", () => {
     const del = defineEntityDeleteHandler("note", noteEntity, {
+      access: { roles: ["Admin"] },
       description: "Deletes a note permanently.",
       agent: { risk: "high" },
     });
     const create = defineEntityCreateHandler("note", noteEntity, {
+      access: { roles: ["Admin"] },
       description: "Files a new note.",
     });
 

package/src/engine/__tests__/extends-registrar.test.ts

@@ -115,10 +115,15 @@ describe("extendsRegistrar", () => {
           fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
         }),
       );
-      r.writeHandler("create", z.object({ name: z.string() }), async () => ({
-        isSuccess: true as const,
-        data: { id: "c1" },
-      }));
+      r.writeHandler(
+        "create",
+        z.object({ name: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: { id: "c1" },
+        }),
+        { access: { openToAll: true } },
+      );
       r.useExtension("audited", "credit");
     });
 
@@ -149,14 +154,24 @@ describe("extendsRegistrar", () => {
       // Explicit handlers — the entity mapping is inferred from the
       // "vehicle:" prefix via tryMapEntity, so the extension's preSave
       // wires onto every entity-scoped handler automatically.
-      r.writeHandler("vehicle:create", z.object({ name: z.string() }), async () => ({
-        isSuccess: true as const,
-        data: { id: "v1" },
-      }));
-      r.writeHandler("vehicle:update", z.object({ id: z.string() }), async () => ({
-        isSuccess: true as const,
-        data: { id: "v1" },
-      }));
+      r.writeHandler(
+        "vehicle:create",
+        z.object({ name: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: { id: "v1" },
+        }),
+        { access: { openToAll: true } },
+      );
+      r.writeHandler(
+        "vehicle:update",
+        z.object({ id: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: { id: "v1" },
+        }),
+        { access: { openToAll: true } },
+      );
       r.useExtension("audited", "vehicle");
     });
 

package/src/engine/__tests__/registry.test.ts

@@ -136,10 +136,14 @@ describe("getAllStreamHandlers", () => {
 
   test("duplicate stream-handler short-name across features qualifies independently, no collision", () => {
     const aiFeature = defineFeature("registry-test-dup-a", (r) => {
-      r.streamHandler("chat:complete", z.object({}), async function* () {});
+      r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+        access: { openToAll: true },
+      });
     });
     const otherFeature = defineFeature("registry-test-dup-b", (r) => {
-      r.streamHandler("chat:complete", z.object({}), async function* () {});
+      r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+        access: { openToAll: true },
+      });
     });
     expect(() => createRegistry([aiFeature, otherFeature])).not.toThrow();
   });
@@ -149,10 +153,14 @@ describe("getAllStreamHandlers", () => {
     // feature.name values (so the earlier Duplicate-feature guard doesn't
     // fire) but toKebab() collapses both to the same qualified name.
     const featureA = defineFeature("registry-test-kebab-dup", (r) => {
-      r.streamHandler("chat:complete", z.object({}), async function* () {});
+      r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+        access: { openToAll: true },
+      });
     });
     const featureB = defineFeature("registryTestKebabDup", (r) => {
-      r.streamHandler("chat:complete", z.object({}), async function* () {});
+      r.streamHandler("chat:complete", z.object({}), async function* () {}, {
+        access: { openToAll: true },
+      });
     });
     expect(() => createRegistry([featureA, featureB])).toThrow(/Duplicate stream handler/);
   });
@@ -188,6 +196,7 @@ describe("double-qualified handler names (#1991)", () => {
         "registry-test-ai-orch:query:duplicate-candidates",
         z.object({}),
         async () => ({}),
+        { access: { openToAll: true } },
       );
     });
 
@@ -196,7 +205,9 @@ describe("double-qualified handler names (#1991)", () => {
 
   test("createRegistry allows a sub-structured short name whose entity prefix merely resembles the feature name", () => {
     const feature = defineFeature("registry-test-invoices", (r) => {
-      r.queryHandler("invoice:mark-paid", z.object({}), async () => ({}));
+      r.queryHandler("invoice:mark-paid", z.object({}), async () => ({}), {
+        access: { openToAll: true },
+      });
     });
 
     expect(() => createRegistry([feature])).not.toThrow();

package/src/engine/access.ts

@@ -1,5 +1,6 @@
 import { ANONYMOUS_ROLE } from "./system-user";
 import type { AccessRule, SessionUser } from "./types";
+import { isOpenToAllGranted } from "./types";
 
 // Default-deny: a handler without an explicit AccessRule is unreachable. To
 // grant access a handler must either list allowed roles or opt into
@@ -18,7 +19,7 @@ export function hasAccess(
 ): boolean {
   if (!access) return false;
   if ("openToAll" in access) {
-    if (access.openToAll !== true) return false;
+    if (!isOpenToAllGranted(access)) return false;
     return !user.roles.includes(ANONYMOUS_ROLE);
   }
   if (access.roles.length === 0) return false;

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

@@ -0,0 +1,200 @@
+import { describe, expect, test } from "bun:test";
+import { z } from "zod";
+import { defineFeature } from "../../define-feature";
+import { createEntity, createTextField } from "../../factories";
+import type { AccessRule } from "../../types";
+import { validateAccessDeclarations } from "../access-declarations";
+
+const noteEntity = createEntity({
+  table: "fw2855_guard_notes",
+  fields: {
+    email: createTextField({ personal: "self", find: "none" }),
+    title: createTextField({ personal: false, reason: "test_fixture" }),
+  },
+});
+
+describe("validateAccessDeclarations", () => {
+  // 1. openToAll reason must be non-empty.
+  test("openToAll with an empty reason throws, naming the handler", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.writeHandler(
+        "note:create",
+        z.object({ title: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: {},
+        }),
+        {
+          access: { openToAll: { reason: "" } },
+        },
+      );
+    });
+    expect(() => validateAccessDeclarations(feature)).toThrow(/Feature notes/);
+    expect(() => validateAccessDeclarations(feature)).toThrow(/"note:create"/);
+  });
+
+  test("openToAll with a non-empty reason boots fine", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.writeHandler(
+        "note:create",
+        z.object({ title: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: {},
+        }),
+        {
+          access: { openToAll: { reason: "internal signup form" } },
+        },
+      );
+    });
+    expect(() => validateAccessDeclarations(feature)).not.toThrow();
+  });
+
+  // 1b. malformed openToAll (from untyped sources) counts as invalid, not a crash.
+  test.each([{ openToAll: false }, { openToAll: {} }])(
+    "malformed openToAll %p throws, naming the handler",
+    (access) => {
+      const feature = defineFeature("notes", (r) => {
+        r.entity("note", noteEntity);
+        r.writeHandler(
+          "note:create",
+          z.object({ title: z.string() }),
+          async () => ({
+            isSuccess: true as const,
+            data: {},
+          }),
+          {
+            // @cast-boundary test — simulates JSON/Designer input that doesn't match the static union
+            access: access as unknown as AccessRule,
+          },
+        );
+      });
+      expect(() => validateAccessDeclarations(feature)).toThrow(/Feature notes/);
+      expect(() => validateAccessDeclarations(feature)).toThrow(/"note:create"/);
+    },
+  );
+
+  // 2. escapeHatch reason must be non-empty.
+  test("escapeHatch with an empty reason throws, naming the handler", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.writeHandler(
+        "note:create",
+        z.object({ title: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: {},
+        }),
+        {
+          access: { roles: ["Admin"] },
+          escapeHatch: { reason: "" },
+        },
+      );
+    });
+    expect(() => validateAccessDeclarations(feature)).toThrow(/Feature notes/);
+    expect(() => validateAccessDeclarations(feature)).toThrow(/"note:create"/);
+  });
+
+  test("escapeHatch with a non-empty reason boots fine", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.writeHandler(
+        "note:create",
+        z.object({ title: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: {},
+        }),
+        {
+          access: { roles: ["Admin"] },
+          escapeHatch: { reason: "cross-tenant note import job" },
+        },
+      );
+    });
+    expect(() => validateAccessDeclarations(feature)).not.toThrow();
+  });
+
+  // 3. openToAll write handler accepting a personal-data field needs publicIntake.
+  test("openToAll write handler accepting a personal-data field without publicIntake throws", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.writeHandler(
+        "note:create",
+        z.object({ email: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: {},
+        }),
+        {
+          access: { openToAll: { reason: "public signup" } },
+        },
+      );
+    });
+    expect(() => validateAccessDeclarations(feature)).toThrow(/Feature notes/);
+    expect(() => validateAccessDeclarations(feature)).toThrow(/"note:create"/);
+    expect(() => validateAccessDeclarations(feature)).toThrow(/"email"/);
+  });
+
+  test("openToAll write handler accepting a personal-data field WITH publicIntake boots fine", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.writeHandler(
+        "note:create",
+        z.object({ email: z.string() }),
+        async () => ({
+          isSuccess: true as const,
+          data: {},
+        }),
+        {
+          access: { openToAll: { reason: "public signup" }, publicIntake: true },
+        },
+      );
+    });
+    expect(() => validateAccessDeclarations(feature)).not.toThrow();
+  });
+
+  // 4. publicIntake is only meaningful on a write handler.
+  test("publicIntake on a query handler throws", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.queryHandler("note:list", z.object({}), async () => [], {
+        access: { openToAll: { reason: "public listing" }, publicIntake: true },
+      });
+    });
+    expect(() => validateAccessDeclarations(feature)).toThrow(/Feature notes/);
+    expect(() => validateAccessDeclarations(feature)).toThrow(/"note:list"/);
+  });
+
+  test("query handler without publicIntake boots fine", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.queryHandler("note:list", z.object({}), async () => [], {
+        access: { openToAll: { reason: "public listing" } },
+      });
+    });
+    expect(() => validateAccessDeclarations(feature)).not.toThrow();
+  });
+
+  test("publicIntake on a stream handler throws", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.streamHandler("note:watch", z.object({}), async function* () {}, {
+        access: { openToAll: { reason: "public stream" }, publicIntake: true },
+      });
+    });
+    expect(() => validateAccessDeclarations(feature)).toThrow(/Feature notes/);
+    expect(() => validateAccessDeclarations(feature)).toThrow(/"note:watch"/);
+  });
+
+  test("stream handler without publicIntake boots fine", () => {
+    const feature = defineFeature("notes", (r) => {
+      r.entity("note", noteEntity);
+      r.streamHandler("note:watch", z.object({}), async function* () {}, {
+        access: { openToAll: { reason: "public stream" } },
+      });
+    });
+    expect(() => validateAccessDeclarations(feature)).not.toThrow();
+  });
+});