@cosmicdrift/kumiko-framework 0.269.2 → 0.273.0

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

@@ -2,12 +2,13 @@ import { describe, expect, test } from "bun:test";
 import { z } from "zod";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
+import { createEntity, createTextField } from "../factories";
 
 describe("validateBoot — projectionList screens", () => {
   test("rejects hand-written searchable:true when the query schema has no search param (3a)", () => {
     const feature = defineFeature("ledger", (r) => {
       r.queryHandler("schedule:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "schedule-list",
@@ -29,7 +30,7 @@ describe("validateBoot — projectionList screens", () => {
         "schedule:list",
         z.object({ search: z.string().optional() }),
         async () => ({ rows: [], nextCursor: null }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
       r.screen({
         id: "schedule-list",
@@ -50,7 +51,7 @@ describe("validateBoot — projectionList screens", () => {
         "schedule:list",
         z.object({ sort: z.string().optional() }),
         async () => ({ rows: [], nextCursor: null }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
       r.screen({
         id: "schedule-list",
@@ -71,7 +72,7 @@ describe("validateBoot — projectionList screens", () => {
         "schedule:list",
         z.object({ search: z.string().optional(), sort: z.string().optional() }),
         async () => ({ rows: [], nextCursor: null }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
       r.screen({
         id: "schedule-list",
@@ -91,7 +92,7 @@ describe("validateBoot — projectionList screens", () => {
   test("passes when the schema offers neither search nor sort and no defaultSort is set", () => {
     const feature = defineFeature("ledger", (r) => {
       r.queryHandler("schedule:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "schedule-list",
@@ -112,7 +113,7 @@ describe("validateBoot — projectionList screens", () => {
         "schedule:list",
         z.object({ search: z.string().optional() }),
         async () => ({ rows: [], nextCursor: null }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
       r.screen({
         id: "schedule-list",
@@ -135,7 +136,7 @@ describe("validateBoot — projectionList screens", () => {
         "schedule:list",
         z.object({ search: z.string().optional() }),
         async () => ({ rows: [], nextCursor: null }),
-        { access: { openToAll: true } },
+        { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
       );
       r.screen({
         id: "download-attempt-list",
@@ -154,7 +155,7 @@ describe("validateBoot — projectionList screens", () => {
   test("rejects hand-authored sortable on a projectionList screen (fw#2165 review)", () => {
     const feature = defineFeature("ledger", (r) => {
       r.queryHandler("schedule:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "schedule-list",
@@ -173,7 +174,7 @@ describe("validateBoot — projectionList screens", () => {
   test("rejects hand-authored paginated on a projectionList screen (fw#2165 review)", () => {
     const feature = defineFeature("ledger", (r) => {
       r.queryHandler("schedule:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "schedule-list",
@@ -202,7 +203,7 @@ describe("validateBoot — projectionList screens", () => {
           z.object({}),
           async () => ({ rows: [], nextCursor: null }),
           {
-            access: { openToAll: true },
+            access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           },
         );
         r.screen({ id: "schedule-detail", type: "custom", renderer: { react: "stub" } });
@@ -251,7 +252,7 @@ describe("validateBoot — projectionList screens", () => {
           "schedule:list",
           z.object({ filter: z.unknown().optional() }),
           async () => ({ rows: [], nextCursor: null }),
-          { access: { openToAll: true } },
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
         );
         r.screen({
           id: "schedule-list",
@@ -274,7 +275,7 @@ describe("validateBoot — projectionList screens", () => {
           z.object({}),
           async () => ({ rows: [], nextCursor: null }),
           {
-            access: { openToAll: true },
+            access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           },
         );
         r.screen({
@@ -297,7 +298,7 @@ describe("validateBoot — projectionList screens", () => {
           "schedule:list",
           z.object({ filters: z.unknown().optional() }),
           async () => ({ rows: [], nextCursor: null }),
-          { access: { openToAll: true } },
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
         );
         r.screen({
           id: "schedule-list",
@@ -326,7 +327,7 @@ describe("validateBoot — projectionList screens", () => {
           "schedule:list",
           z.object({ filters: z.unknown().optional() }),
           async () => ({ rows: [], nextCursor: null }),
-          { access: { openToAll: true } },
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
         );
         r.screen({
           id: "schedule-list",
@@ -363,7 +364,7 @@ describe("validateBoot — projectionList screens", () => {
           "schedule:list",
           z.object({ filters: z.unknown().optional() }),
           async () => ({ rows: [], nextCursor: null }),
-          { access: { openToAll: true } },
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
         );
         r.screen({
           id: "schedule-list",
@@ -386,7 +387,7 @@ describe("validateBoot — projectionList screens", () => {
           z.object({}),
           async () => ({ rows: [], nextCursor: null }),
           {
-            access: { openToAll: true },
+            access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           },
         );
         r.screen({
@@ -417,7 +418,7 @@ describe("validateBoot — projectionList screens", () => {
           "schedule:list",
           z.object({ filter: z.unknown().optional(), filters: z.unknown().optional() }),
           async () => ({ rows: [], nextCursor: null }),
-          { access: { openToAll: true } },
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
         );
         r.screen({
           id: "schedule-list",
@@ -441,5 +442,95 @@ describe("validateBoot — projectionList screens", () => {
       });
       expect(() => validateBoot([feature])).not.toThrow();
     });
+
+    test("a reference facet targeting an unknown entity is rejected", () => {
+      const feature = defineFeature("ledger", (r) => {
+        r.queryHandler(
+          "schedule:list",
+          z.object({ filters: z.unknown().optional() }),
+          async () => ({ rows: [], nextCursor: null }),
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
+        );
+        r.screen({
+          id: "schedule-list",
+          type: "projectionList",
+          query: "ledger:query:schedule:list",
+          columns: ["tenant"],
+          facets: [{ field: "tenant", type: "reference", label: "Tenant", entity: "tenant" }],
+        });
+        r.translations({
+          keys: { "screen:schedule-list.title": { de: "Liste", en: "List" } },
+        });
+      });
+      expect(() => validateBoot([feature])).toThrow(/does not resolve to a registered entity/);
+    });
+
+    test("a reference facet targeting a known entity passes boot", () => {
+      const feature = defineFeature("ledger", (r) => {
+        r.entity(
+          "tenant",
+          createEntity({
+            table: "Tenants",
+            fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+          }),
+        );
+        r.queryHandler(
+          "schedule:list",
+          z.object({ filters: z.unknown().optional() }),
+          async () => ({ rows: [], nextCursor: null }),
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
+        );
+        r.screen({
+          id: "schedule-list",
+          type: "projectionList",
+          query: "ledger:query:schedule:list",
+          columns: ["tenant"],
+          facets: [{ field: "tenant", type: "reference", label: "Tenant", entity: "tenant" }],
+        });
+        r.translations({
+          keys: {
+            "screen:schedule-list.title": { de: "Liste", en: "List" },
+            "ledger:entity:tenant:field:name": { de: "Name", en: "Name" },
+          },
+        });
+      });
+      expect(() => validateBoot([feature])).not.toThrow();
+    });
+
+    test("a reference facet filtering by an id field with no same-named column boots (displays a different label column)", () => {
+      const feature = defineFeature("ledger", (r) => {
+        r.entity(
+          "property",
+          createEntity({
+            table: "Properties",
+            fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+          }),
+        );
+        r.queryHandler(
+          "schedule:list",
+          z.object({ filters: z.unknown().optional() }),
+          async () => ({ rows: [], nextCursor: null }),
+          { access: { openToAll: { reason: "test handler callable by any signed-in test user" } } },
+        );
+        r.screen({
+          id: "schedule-list",
+          type: "projectionList",
+          query: "ledger:query:schedule:list",
+          // Filters by propertyId, displays propertyLabel — no "propertyId"
+          // column exists, and none should be required for a reference facet.
+          columns: ["propertyLabel"],
+          facets: [
+            { field: "propertyId", type: "reference", label: "Property", entity: "property" },
+          ],
+        });
+        r.translations({
+          keys: {
+            "screen:schedule-list.title": { de: "Liste", en: "List" },
+            "ledger:entity:property:field:name": { de: "Name", en: "Name" },
+          },
+        });
+      });
+      expect(() => validateBoot([feature])).not.toThrow();
+    });
   });
 });

package/src/engine/__tests__/boot-validator-query-output-schema.test.ts

@@ -20,7 +20,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionList column not in the paged query's row shape throws", () => {
     const feature = defineFeature("catalog", (r) => {
       r.queryHandler("items:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: pagedSchema,
       });
       r.screen({
@@ -39,7 +39,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionList column present in the row shape does not throw", () => {
     const feature = defineFeature("catalog", (r) => {
       r.queryHandler("items:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: pagedSchema,
       });
       r.screen({
@@ -56,7 +56,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionList column with a label is exempt as a virtual/computed column", () => {
     const feature = defineFeature("catalog", (r) => {
       r.queryHandler("items:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: pagedSchema,
       });
       r.screen({
@@ -78,7 +78,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionList without a declared outputSchema skips the column check entirely", () => {
     const feature = defineFeature("catalog", (r) => {
       r.queryHandler("items:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "items",
@@ -94,7 +94,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionList outputSchema that isn't a ZodObject (e.g. a union) skips the column check", () => {
     const feature = defineFeature("catalog", (r) => {
       r.queryHandler("items:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.union([pagedSchema, z.null()]),
       });
       r.screen({
@@ -111,11 +111,11 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("relatedList column not in the query's row shape throws", () => {
     const feature = defineFeature("app", (r) => {
       r.queryHandler("rent:detail", z.object({}), async () => ({ description: "x" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({ description: z.string() }),
       });
       r.queryHandler("rent:payments", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({
           rows: z.array(z.object({ amount: z.number() })),
           nextCursor: z.string().nullable(),
@@ -142,10 +142,153 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
     );
   });
 
+  test("relatedList toolbarAction visible.field not in the projectionDetail's own outputSchema throws", () => {
+    const feature = defineFeature("app", (r) => {
+      r.queryHandler("lease:detail", z.object({}), async () => ({ id: "1", status: "active" }), {
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        outputSchema: z.object({ id: z.string(), status: z.string() }),
+      });
+      r.queryHandler(
+        "lease:positions",
+        z.object({}),
+        async () => ({ rows: [], nextCursor: null }),
+        {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+          outputSchema: z.object({
+            rows: z.array(z.object({ id: z.string() })),
+            nextCursor: z.string().nullable(),
+          }),
+        },
+      );
+      r.screen({
+        id: "lease-detail",
+        type: "projectionDetail",
+        query: "app:query:lease:detail",
+        layout: {
+          sections: [
+            {
+              kind: "relatedList",
+              title: "Positions",
+              query: "app:query:lease:positions",
+              columns: ["id"],
+              toolbarActions: [
+                {
+                  kind: "navigate",
+                  id: "create",
+                  label: "Add position",
+                  screen: "position-create",
+                  visible: { field: "ghost-status", eq: "active" },
+                },
+              ],
+            },
+          ],
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(
+      /toolbarAction "create" visible\.field references unknown field "ghost-status"/,
+    );
+  });
+
+  test("relatedList toolbarAction navigate params source field not in the projectionDetail's own outputSchema throws", () => {
+    const feature = defineFeature("app", (r) => {
+      r.queryHandler("lease:detail", z.object({}), async () => ({ id: "1" }), {
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        outputSchema: z.object({ id: z.string() }),
+      });
+      r.queryHandler(
+        "lease:positions",
+        z.object({}),
+        async () => ({ rows: [], nextCursor: null }),
+        {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+          outputSchema: z.object({
+            rows: z.array(z.object({ id: z.string() })),
+            nextCursor: z.string().nullable(),
+          }),
+        },
+      );
+      r.screen({
+        id: "lease-detail",
+        type: "projectionDetail",
+        query: "app:query:lease:detail",
+        layout: {
+          sections: [
+            {
+              kind: "relatedList",
+              title: "Positions",
+              query: "app:query:lease:positions",
+              columns: ["id"],
+              toolbarActions: [
+                {
+                  kind: "navigate",
+                  id: "create",
+                  label: "Add position",
+                  screen: "position-create",
+                  params: { map: { leaseId: "ghost-id" } },
+                },
+              ],
+            },
+          ],
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).toThrow(
+      /toolbarAction "create" params references unknown field "ghost-id"/,
+    );
+  });
+
+  test("relatedList toolbarAction visible/params present in the projectionDetail's own outputSchema does not throw", () => {
+    const feature = defineFeature("app", (r) => {
+      r.queryHandler("lease:detail", z.object({}), async () => ({ id: "1", status: "active" }), {
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+        outputSchema: z.object({ id: z.string(), status: z.string() }),
+      });
+      r.queryHandler(
+        "lease:positions",
+        z.object({}),
+        async () => ({ rows: [], nextCursor: null }),
+        {
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
+          outputSchema: z.object({
+            rows: z.array(z.object({ id: z.string() })),
+            nextCursor: z.string().nullable(),
+          }),
+        },
+      );
+      r.screen({
+        id: "lease-detail",
+        type: "projectionDetail",
+        query: "app:query:lease:detail",
+        layout: {
+          sections: [
+            {
+              kind: "relatedList",
+              title: "Positions",
+              query: "app:query:lease:positions",
+              columns: ["id"],
+              toolbarActions: [
+                {
+                  kind: "navigate",
+                  id: "create",
+                  label: "Add position",
+                  screen: "position-create",
+                  visible: { field: "status", eq: "active" },
+                  params: { map: { leaseId: "id" } },
+                },
+              ],
+            },
+          ],
+        },
+      });
+    });
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
   test("projectionDetail header.title referencing an unknown field throws", () => {
     const feature = defineFeature("app", (r) => {
       r.queryHandler("tenant:detail", z.object({}), async () => ({ id: "1", name: "x" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({ id: z.string(), name: z.string() }),
       });
       r.screen({
@@ -164,7 +307,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionDetail header.status referencing an unknown field throws", () => {
     const feature = defineFeature("app", (r) => {
       r.queryHandler("tenant:detail", z.object({}), async () => ({ id: "1", name: "x" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({ id: z.string(), name: z.string() }),
       });
       r.screen({
@@ -181,7 +324,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("projectionDetail metrics referencing an unknown field throws", () => {
     const feature = defineFeature("app", (r) => {
       r.queryHandler("tenant:detail", z.object({}), async () => ({ id: "1", balance: 0 }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({ id: z.string(), balance: z.number() }),
       });
       r.screen({
@@ -214,7 +357,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
         z.object({}),
         async () => ({ id: "1", name: "x", balance: 0 }),
         {
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           outputSchema: z.object({
             id: z.string(),
             name: z.string(),
@@ -241,7 +384,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("dashboard stat panel valueField referencing an unknown field throws", () => {
     const feature = defineFeature("demo", (r) => {
       r.queryHandler("open-count", z.object({}), async () => ({ value: "0" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({ value: z.string() }),
       });
       r.screen({
@@ -269,7 +412,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("dashboard stat-group child deltaField referencing an unknown field throws", () => {
     const feature = defineFeature("demo", (r) => {
       r.queryHandler("net-worth", z.object({}), async () => ({ value: "0" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({ value: z.string() }),
       });
       r.screen({
@@ -308,7 +451,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
   test("dashboard list panel column not in the query's row shape throws", () => {
     const feature = defineFeature("demo", (r) => {
       r.queryHandler("next-events", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
         outputSchema: z.object({
           rows: z.array(z.object({ title: z.string() })),
           nextCursor: z.string().nullable(),
@@ -342,7 +485,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
         defineQueryHandler({
           name: "items:detail",
           schema: z.object({ id: z.string() }),
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           outputSchema: z.object({ id: z.string(), name: z.string() }),
           handler: async () => ({ id: "1", name: "x" }),
         }),
@@ -366,7 +509,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
         definePagedQueryHandler({
           name: "items:list",
           schema: z.object({}),
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           outputSchema: pagedSchema,
           handler: async () => ({ rows: [], nextCursor: null }),
         }),
@@ -390,7 +533,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
         definePagedQueryHandler({
           name: "items:list",
           schema: z.object({}),
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           // Row schema passed directly instead of wrapping it in
           // { rows: [...], nextCursor } — the mistake fw#2493's follow-up
           // check catches instead of silently skipping every column check.
@@ -417,7 +560,7 @@ describe("validateBoot — query output schema column refs (fw#2493)", () => {
         definePagedQueryHandler({
           name: "items:list",
           schema: z.object({}),
-          access: { openToAll: true },
+          access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
           outputSchema: pagedSchema,
           handler: async () => ({ rows: [], nextCursor: null }),
         }),

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

@@ -36,7 +36,7 @@ describe("validateBoot — query QN refs (fw#2178)", () => {
   test("projectionDetail relatedList section with a dead query QN throws (b)", () => {
     const feature = defineFeature("app", (r) => {
       r.queryHandler("rent:detail", z.object({}), async () => ({ description: "x" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "rent-detail",
@@ -96,7 +96,7 @@ describe("validateBoot — query QN refs (fw#2178)", () => {
   test("dashboard filter optionsQuery with a dead query QN throws", () => {
     const feature = defineFeature("demo", (r) => {
       r.queryHandler("open-count", z.object({}), async () => ({ value: "0" }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
       r.screen({
         id: "overview",
@@ -132,7 +132,7 @@ describe("validateBoot — query QN refs (fw#2178)", () => {
   test("a screen referencing a query registered by a different mounted feature does not throw (d)", () => {
     const provider = defineFeature("catalog", (r) => {
       r.queryHandler("items:list", z.object({}), async () => ({ rows: [], nextCursor: null }), {
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
     });
     const consumer = defineFeature("storefront", (r) => {

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

@@ -44,7 +44,7 @@ describe("S0 Integration — full surface stack", () => {
         name: "compliance:query:for-tenant",
         schema: z.object({}),
         handler: async () => ({ profile: "eu-dsgvo" }) as never,
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
     });
 
@@ -101,7 +101,7 @@ describe("S0 Integration — full surface stack", () => {
         name: "user:list",
         schema: z.object({}),
         handler: async () => ({ rows: [], nextCursor: null }) as never,
-        access: { openToAll: true },
+        access: { openToAll: { reason: "test handler callable by any signed-in test user" } },
       });
 
       r.useExtension(EXT_USER_DATA, "user", {});