@cosmicdrift/kumiko-framework 0.256.0 → 0.258.0

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

@@ -2558,6 +2558,234 @@ describe("boot-validator", () => {
     });
   });
 
+  // --- secretMint-Screen (fw#2548) ---
+  // Mint-form → one-time reveal → confirm. Shares its six inline-form checks
+  // with actionForm (validateInlineFormScreen), plus its own reveal.fields
+  // checks: non-empty, unique `field`, non-empty `label`.
+  describe("secretMint screen (fw#2548)", () => {
+    type SecretMintOverride = {
+      readonly handler?: string | undefined;
+      readonly fields?: Record<string, unknown>;
+      readonly sections?: ReadonlyArray<{
+        readonly title: string;
+        readonly fields: readonly string[];
+      }>;
+      readonly reveal?: {
+        readonly fields: ReadonlyArray<{
+          readonly field: string;
+          readonly label: string;
+          readonly display?: "code" | "list";
+        }>;
+      };
+      readonly redirect?: string;
+      readonly extraScreens?: readonly string[];
+      readonly confirm?: {
+        readonly handler?: string;
+        readonly fields?: Record<string, unknown>;
+        readonly sections?: ReadonlyArray<{
+          readonly title: string;
+          readonly fields: readonly string[];
+        }>;
+        readonly carry?: readonly string[];
+        readonly mode?: "single" | "wizard" | "tabs";
+        readonly draft?: boolean;
+      };
+    };
+
+    function makeFeature(override: SecretMintOverride = {}) {
+      const handler = override.handler ?? "shop:write:token:mint";
+      const fields = override.fields ?? { label: { type: "text" } };
+      const sections = override.sections ?? [{ title: "Mint", fields: ["label"] }];
+      const reveal = override.reveal ?? {
+        fields: [{ field: "token", label: "shop:screen:mint-token.field:token" }],
+      };
+      const confirmOverride = override.confirm;
+      return defineFeature("shop", (r) => {
+        r.writeHandler({
+          name: "token:mint",
+          schema: { _type: "stub" } as never,
+          handler: async () => ({ isSuccess: true, data: {} }) as never,
+          access: { openToAll: true },
+        });
+        if (confirmOverride !== undefined) {
+          r.writeHandler({
+            name: "token:confirm",
+            schema: { _type: "stub" } as never,
+            handler: async () => ({ isSuccess: true, data: {} }) as never,
+            access: { openToAll: true },
+          });
+        }
+        r.screen({
+          id: "mint-token",
+          type: "secretMint",
+          handler,
+          fields: fields as never,
+          layout: { sections: sections as never },
+          reveal: reveal as never,
+          ...(override.redirect !== undefined && { redirect: override.redirect }),
+          ...(confirmOverride !== undefined && {
+            confirm: {
+              handler: confirmOverride.handler ?? "shop:write:token:confirm",
+              fields: (confirmOverride.fields ?? { code: { type: "text" } }) as never,
+              layout: {
+                sections: (confirmOverride.sections ?? [
+                  { title: "Confirm", fields: ["code"] },
+                ]) as never,
+                ...(confirmOverride.mode !== undefined && { mode: confirmOverride.mode }),
+                ...(confirmOverride.draft !== undefined && { draft: confirmOverride.draft }),
+              },
+              ...(confirmOverride.carry !== undefined && { carry: confirmOverride.carry }),
+            },
+          }),
+        });
+        for (const extra of override.extraScreens ?? []) {
+          r.screen({
+            id: extra,
+            type: "custom",
+            renderer: { react: "stub" },
+          });
+        }
+      });
+    }
+
+    test("happy path: handler + fields + layout + reveal konsistent → kein Throw", () => {
+      expect(() => validateBoot([makeFeature()])).not.toThrow();
+    });
+
+    test("handler nicht als write-handler registriert → Throw", () => {
+      expect(() => validateBoot([makeFeature({ handler: "shop:query:token:list" })])).toThrow(
+        /\(secretMint\) handler "shop:query:token:list" is not a registered write-handler/,
+      );
+    });
+
+    // secretMint allows an empty fields map (input-less mint, fw#2838) — but
+    // the default `sections` still references "label", which no longer
+    // exists once `fields` is empty, so this still throws (just via the
+    // layout check instead of the fields-map check).
+    test("fields empty-Map without also clearing sections → Throw", () => {
+      expect(() => validateBoot([makeFeature({ fields: {} })])).toThrow(
+        /\(secretMint\) layout references unknown field "label"/,
+      );
+    });
+
+    test("layout referenziert unknown field → Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature({ sections: [{ title: "x", fields: ["ghost"] }] })]),
+      ).toThrow(/\(secretMint\) layout references unknown field "ghost"/);
+    });
+
+    test("redirect → existing screen-id → kein Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature({ redirect: "after-mint", extraScreens: ["after-mint"] })]),
+      ).not.toThrow();
+    });
+
+    test("redirect → unknown screen-id → Throw", () => {
+      expect(() => validateBoot([makeFeature({ redirect: "ghost-screen" })])).toThrow(
+        /\(secretMint\) redirect "ghost-screen" does not resolve to a registered screen/,
+      );
+    });
+
+    test("reveal.fields leer → Throw", () => {
+      expect(() => validateBoot([makeFeature({ reveal: { fields: [] } })])).toThrow(
+        /has an empty reveal\.fields list/,
+      );
+    });
+
+    test("reveal.fields mit doppeltem field → Throw", () => {
+      expect(() =>
+        validateBoot([
+          makeFeature({
+            reveal: {
+              fields: [
+                { field: "token", label: "a" },
+                { field: "token", label: "b" },
+              ],
+            },
+          }),
+        ]),
+      ).toThrow(/reveal\.fields has a duplicate field "token"/);
+    });
+
+    test("reveal.fields entry mit leerem label → Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature({ reveal: { fields: [{ field: "token", label: "" }] } })]),
+      ).toThrow(/reveal\.fields entry "token" has an empty or non-string "label"/);
+    });
+
+    // --- input-less mint (fw#2838): fields: {} + layout.sections: [] is the
+    // only valid empty shape — the secret is server-generated, the mint step
+    // is just its submit button.
+    test("empty fields + empty sections (input-less mint) → no throw", () => {
+      expect(() => validateBoot([makeFeature({ fields: {}, sections: [] })])).not.toThrow();
+    });
+
+    test("empty fields but non-empty sections list → Throw", () => {
+      expect(() =>
+        validateBoot([makeFeature({ fields: {}, sections: [{ title: "x", fields: ["ghost"] }] })]),
+      ).toThrow(/\(secretMint\) layout references unknown field "ghost"/);
+    });
+
+    test("non-empty fields but empty sections list → Throw", () => {
+      expect(() => validateBoot([makeFeature({ sections: [] })])).toThrow(
+        /\(secretMint\) has an empty sections list/,
+      );
+    });
+
+    // --- confirm step (fw#2838) ---
+    describe("confirm step", () => {
+      test("happy path: confirm handler + fields + layout consistent → no throw", () => {
+        expect(() => validateBoot([makeFeature({ confirm: {} })])).not.toThrow();
+      });
+
+      test("confirm.handler not a registered write-handler → Throw", () => {
+        expect(() =>
+          validateBoot([makeFeature({ confirm: { handler: "shop:query:token:list" } })]),
+        ).toThrow(
+          /\(secretMint confirm\) handler "shop:query:token:list" is not a registered write-handler/,
+        );
+      });
+
+      test("confirm.fields empty map → Throw", () => {
+        expect(() => validateBoot([makeFeature({ confirm: { fields: {} } })])).toThrow(
+          /\(secretMint confirm\) has empty fields map/,
+        );
+      });
+
+      test("confirm layout references unknown field → Throw", () => {
+        expect(() =>
+          validateBoot([
+            makeFeature({ confirm: { sections: [{ title: "x", fields: ["ghost"] }] } }),
+          ]),
+        ).toThrow(/\(secretMint confirm\) layout references unknown field "ghost"/);
+      });
+
+      test("confirm layout mode 'wizard' → Throw", () => {
+        expect(() => validateBoot([makeFeature({ confirm: { mode: "wizard" } })])).toThrow(
+          /\(secretMint confirm\) sets layout\.mode: "wizard"/,
+        );
+      });
+
+      test("confirm layout draft true → Throw", () => {
+        expect(() => validateBoot([makeFeature({ confirm: { draft: true } })])).toThrow(
+          /\(secretMint confirm\) sets layout\.draft: true/,
+        );
+      });
+
+      test("carry entry colliding with a confirm.fields name → Throw", () => {
+        expect(() => validateBoot([makeFeature({ confirm: { carry: ["code"] } })])).toThrow(
+          /\(secretMint confirm\) carry field "code" also names a confirm\.fields entry/,
+        );
+      });
+
+      test("carry entry that is not a confirm.fields name → no throw", () => {
+        expect(() =>
+          validateBoot([makeFeature({ confirm: { carry: ["setupToken"] } })]),
+        ).not.toThrow();
+      });
+    });
+  });
+
   // --- configEdit-Screen ---
   // Form gegen das bundled config-feature. Boot-Validator prüft:
   //   1) fields non-empty + jeder mit type-Discriminator

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

@@ -0,0 +1,149 @@
+// fw#2766 — boot guard for join-row entities. The read gate needs the registry,
+// which only exists at request time, so the raw executor stays ungated when a
+// caller doesn't wire `parentVisibility`. That keeps framework-internal cascade
+// and GDPR paths working, and moves enforcement here: a hand-written list/detail
+// handler on a parentRef entity must fail boot rather than leak silently.
+
+import { describe, expect, test } from "bun:test";
+import { z } from "zod";
+import { defineFeature } from "../../define-feature";
+import { defineEntityDetailHandler, defineEntityListHandler } from "../../entity-handlers";
+import { createEntity, createTextField } from "../../factories";
+import type { FeatureDefinition } from "../../types";
+import { validateParentRefs } from "../parent-ref";
+
+const textField = () =>
+  createTextField({
+    required: true,
+    maxLength: 64,
+    personal: false,
+    reason: "technical_reference",
+  });
+
+const hostEntity = createEntity({
+  table: "read_hosts",
+  fields: { name: textField() },
+});
+
+function joinEntity(parentRef: {
+  entityTypeField: string;
+  entityIdField: string;
+  allowedTypes?: readonly string[];
+}) {
+  return createEntity({
+    table: "read_joins",
+    fields: { entityType: textField(), entityId: textField() },
+    parentRef,
+  });
+}
+
+const validRef = { entityTypeField: "entityType", entityIdField: "entityId" } as const;
+
+function featureMapOf(...features: readonly FeatureDefinition[]) {
+  return new Map(features.map((f) => [f.name, f]));
+}
+
+function validate(feature: FeatureDefinition, extra: readonly FeatureDefinition[] = []): void {
+  validateParentRefs(feature, featureMapOf(feature, ...extra));
+}
+
+describe("validateParentRefs", () => {
+  test("accepts a parentRef whose fields exist and whose list/detail are convention handlers", () => {
+    const entity = joinEntity(validRef);
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", entity);
+      r.queryHandler(defineEntityListHandler("join", entity, { access: { openToAll: true } }));
+      r.queryHandler(defineEntityDetailHandler("join", entity, { access: { openToAll: true } }));
+    });
+    expect(() => validate(feature)).not.toThrow();
+  });
+
+  test("an entity with no parentRef is not checked at all", () => {
+    const feature = defineFeature("plain", (r) => {
+      r.entity("host", hostEntity);
+      r.queryHandler({
+        name: "host:list",
+        schema: z.object({}),
+        handler: async () => ({ rows: [], nextCursor: null }),
+        access: { openToAll: true },
+      });
+    });
+    expect(() => validate(feature)).not.toThrow();
+  });
+
+  test("rejects an entityTypeField that is not a declared field", () => {
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity({ ...validRef, entityTypeField: "nope" }));
+    });
+    expect(() => validate(feature)).toThrow(/entityTypeField references "nope"/);
+  });
+
+  test("rejects an entityIdField that is not a declared field", () => {
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity({ ...validRef, entityIdField: "nope" }));
+    });
+    expect(() => validate(feature)).toThrow(/entityIdField references "nope"/);
+  });
+
+  test("rejects an allowedTypes entry that names no registered entity", () => {
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity({ ...validRef, allowedTypes: ["ghost"] }));
+    });
+    expect(() => validate(feature)).toThrow(/names "ghost"/);
+  });
+
+  test("accepts an allowedTypes entry registered by another feature", () => {
+    const hosts = defineFeature("hosts", (r) => {
+      r.entity("host", hostEntity);
+    });
+    const entity = joinEntity({ ...validRef, allowedTypes: ["host"] });
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", entity);
+      r.queryHandler(defineEntityListHandler("join", entity, { access: { openToAll: true } }));
+    });
+    expect(() => validate(feature, [hosts])).not.toThrow();
+  });
+
+  test("rejects an allowedTypes host that is itself a join row — no recursive gating", () => {
+    const others = defineFeature("others", (r) => {
+      r.entity("other", joinEntity(validRef));
+    });
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity({ ...validRef, allowedTypes: ["other"] }));
+    });
+    expect(() => validate(feature, [others])).toThrow(/itself declares a parentRef/);
+  });
+
+  test("rejects a hand-written list handler, which would bypass the read gate", () => {
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity(validRef));
+      r.queryHandler({
+        name: "join:list",
+        schema: z.object({}),
+        handler: async () => ({ rows: [], nextCursor: null }),
+        access: { openToAll: true },
+      });
+    });
+    expect(() => validate(feature)).toThrow(/join:list/);
+  });
+
+  test("rejects a hand-written detail handler too", () => {
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity(validRef));
+      r.queryHandler({
+        name: "join:detail",
+        schema: z.object({ id: z.uuid() }),
+        handler: async () => null,
+        access: { openToAll: true },
+      });
+    });
+    expect(() => validate(feature)).toThrow(/join:detail/);
+  });
+
+  test("registering no list/detail handler at all is allowed", () => {
+    const feature = defineFeature("joins", (r) => {
+      r.entity("join", joinEntity(validRef));
+    });
+    expect(() => validate(feature)).not.toThrow();
+  });
+});

package/src/engine/boot-validator/action-wiring.ts

@@ -1,4 +1,9 @@
-import { isFieldsEditSection, normalizeEditField, normalizeListColumn } from "../screen-helpers";
+import {
+  isEditLayoutScreen,
+  isFieldsEditSection,
+  normalizeEditField,
+  normalizeListColumn,
+} from "../screen-helpers";
 import type {
   EditFieldSpec,
   EditLayout,
@@ -138,12 +143,7 @@ export function validateFieldWiring(feature: FeatureDefinition): void {
       validateColumnsNoFunctions(feature.name, screen.id, screen.type, screen.columns);
       continue;
     }
-    if (
-      screen.type === "entityEdit" ||
-      screen.type === "actionForm" ||
-      screen.type === "configEdit" ||
-      screen.type === "projectionDetail"
-    ) {
+    if (isEditLayoutScreen(screen)) {
       validateEditLayoutNoFunctions(feature.name, screen.id, screen.type, screen.layout);
       continue;
     }

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

@@ -45,6 +45,7 @@ import {
   warnOnNavAccessInversion,
 } from "./nav";
 import { collectClaimKeys, validateOwnershipRules } from "./ownership";
+import { validateParentRefs } from "./parent-ref";
 import { validatePiiAndRetention } from "./pii-retention";
 import {
   validateProjectionListScreens,
@@ -195,6 +196,7 @@ export function validateBoot(
     validateConfigKeyBacking(feature);
     validateConfigKeyPiiEncrypted(feature);
     validateOwnershipRules(feature, allClaimKeys, knownRoles);
+    validateParentRefs(feature, featureMap);
     validateMultiStreamProjections(feature);
     // Vor validateScreens: dessen visible/entityId-Feldref-Checks werfen für
     // einen Function-Wert bereits (mit verwirrender "unknown field undefined"-

package/src/engine/boot-validator/parent-ref.ts

@@ -0,0 +1,96 @@
+import { ENTITY_CONVENTION_QUERY_BRAND } from "@cosmicdrift/kumiko-types/handlers";
+import type { EntityDefinition, FeatureDefinition, QueryHandlerDef } from "../types";
+
+// --- Parent-ref boot validation (fw#2766) ---
+//
+// Join-row entities (EntityDefinition.parentRef) derive both the write-path
+// deny and the read-path SQL gate from one declaration. This is the boot-time
+// half of the fail-closed guarantee: the read gate itself (db/parent-ref-
+// clause.ts) passes an ungated query through when no ParentVisibilityOption
+// was supplied — throwing there would 500 every custom handler and
+// framework-internal detail() call that doesn't wire it, so the enforcement
+// has to happen loudly here instead, once, at boot.
+
+function findEntity(
+  featureMap: ReadonlyMap<string, FeatureDefinition>,
+  entityName: string,
+): EntityDefinition | undefined {
+  for (const f of featureMap.values()) {
+    const entity = f.entities?.[entityName];
+    if (entity) return entity;
+  }
+  return undefined;
+}
+
+function findQueryHandler(
+  featureMap: ReadonlyMap<string, FeatureDefinition>,
+  handlerName: string,
+): QueryHandlerDef | undefined {
+  for (const f of featureMap.values()) {
+    const handler = f.queryHandlers[handlerName];
+    if (handler) return handler;
+  }
+  return undefined;
+}
+
+export function validateParentRefs(
+  feature: FeatureDefinition,
+  featureMap: ReadonlyMap<string, FeatureDefinition>,
+): void {
+  for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
+    const parentRef = entity.parentRef;
+    if (parentRef === undefined) continue;
+
+    if (entity.fields[parentRef.entityTypeField] === undefined) {
+      throw new Error(
+        `[Kumiko ParentRef] entity "${entityName}".parentRef.entityTypeField references ` +
+          `"${parentRef.entityTypeField}" — which is not a declared field on "${entityName}" ` +
+          `(feature: "${feature.name}"). Fix: point entityTypeField at a real field on the entity.`,
+      );
+    }
+    if (entity.fields[parentRef.entityIdField] === undefined) {
+      throw new Error(
+        `[Kumiko ParentRef] entity "${entityName}".parentRef.entityIdField references ` +
+          `"${parentRef.entityIdField}" — which is not a declared field on "${entityName}" ` +
+          `(feature: "${feature.name}"). Fix: point entityIdField at a real field on the entity.`,
+      );
+    }
+
+    for (const hostName of parentRef.allowedTypes ?? []) {
+      const host = findEntity(featureMap, hostName);
+      if (host === undefined) {
+        throw new Error(
+          `[Kumiko ParentRef] entity "${entityName}".parentRef.allowedTypes names "${hostName}" ` +
+            `— no entity with that name is registered in this feature set (feature: ` +
+            `"${feature.name}"). Fix: remove "${hostName}" from allowedTypes, or register it.`,
+        );
+      }
+      if (host.parentRef !== undefined) {
+        throw new Error(
+          `[Kumiko ParentRef] entity "${entityName}".parentRef.allowedTypes names "${hostName}" ` +
+            `— which itself declares a parentRef (feature: "${feature.name}"). A join-row ` +
+            `entity can't act as a host for another join-row entity (no recursive gating). ` +
+            `Fix: remove "${hostName}" from allowedTypes, or drop its own parentRef.`,
+        );
+      }
+    }
+
+    for (const verb of ["list", "detail"] as const) {
+      const handlerName = `${entityName}:${verb}`;
+      const handler = findQueryHandler(featureMap, handlerName);
+      // skip: no handler registered for this verb — nothing to brand-check
+      if (handler === undefined) continue;
+      if (handler[ENTITY_CONVENTION_QUERY_BRAND] !== true) {
+        throw new Error(
+          `[Kumiko ParentRef] query handler "${handlerName}" does not carry ` +
+            `ENTITY_CONVENTION_QUERY_BRAND, but entity "${entityName}" declares a parentRef ` +
+            `(feature: "${feature.name}"). A hand-written handler bypasses the parent-ref ` +
+            `read-gate unless it explicitly wires parentVisibility. Fix: register "${handlerName}" ` +
+            `via defineEntityListHandler/defineEntityDetailHandler (or defineEntityQueryHandler), ` +
+            `or pass { parentVisibility: { entities: ctx.registry.getAllEntities() } } to ` +
+            `executor.${verb} yourself.`,
+        );
+      }
+    }
+  }
+}

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

@@ -1,5 +1,11 @@
 import { QnTypes, qualifyEntityName } from "../qualified-name";
-import type { FeatureDefinition, ProjectionListScreenDefinition, QueryHandlerDef } from "../types";
+import { isEditLayoutScreen } from "../screen-helpers";
+import type {
+  EditRelatedListSection,
+  FeatureDefinition,
+  ProjectionListScreenDefinition,
+  QueryHandlerDef,
+} from "../types";
 import { SEARCHABLE_FALSE_WHITELIST } from "./entity-list-screens";
 import { getZodObjectShape } from "./zod-shape";
 
@@ -122,6 +128,32 @@ export function validateProjectionListScreens(features: readonly FeatureDefiniti
   }
 }
 
+function validateRelatedListSearchable(
+  prefix: string,
+  section: EditRelatedListSection,
+  schema: QueryHandlerDef["schema"] | undefined,
+): void {
+  // skip: not searchable, or the schema already accepts search — nothing to reject.
+  if (section.searchable !== true || schemaAccepts(schema, "search")) return;
+  throw new Error(
+    `${prefix}: searchable: true but query "${section.query}" has no "search" parameter in its Zod schema`,
+  );
+}
+
+function validateRelatedListFacets(
+  prefix: string,
+  section: EditRelatedListSection,
+  schema: QueryHandlerDef["schema"] | undefined,
+): void {
+  // skip: no facets declared — nothing to reject.
+  if (section.facets === undefined || section.facets.length === 0) return;
+  // skip: the schema already accepts filters — nothing to reject.
+  if (schemaAccepts(schema, "filters")) return;
+  throw new Error(
+    `${prefix}: declares facets but query "${section.query}" has no "filters" parameter in its Zod schema — add filters: z.array(z.object({ field: z.string(), op: z.literal("in"), value: z.unknown() })).optional() (or reuse entityListSchema's shape) to the handler's schema.`,
+  );
+}
+
 // relatedList sections declare search/facets the same way a projectionList
 // screen does, and hit the same 422 footgun: definePagedQueryHandler doesn't
 // auto-merge params into the handler's own Zod schema (fw#2165/#2224), so an
@@ -133,32 +165,13 @@ export function validateRelatedListSectionQueries(features: readonly FeatureDefi
   const queryHandlers = buildQueryHandlerMap(features);
   for (const feature of features) {
     for (const screen of Object.values(feature.screens)) {
-      if (
-        screen.type !== "projectionDetail" &&
-        screen.type !== "entityEdit" &&
-        screen.type !== "actionForm" &&
-        screen.type !== "configEdit"
-      ) {
-        continue;
-      }
+      if (!isEditLayoutScreen(screen)) continue;
       for (const section of screen.layout.sections) {
         if (section.kind !== "relatedList") continue;
         const prefix = `[Feature ${feature.name}] Screen "${screen.id}" (${screen.type}) relatedList section "${section.title}"`;
         const schema = queryHandlers.get(section.query)?.schema;
-        if (section.searchable === true && !schemaAccepts(schema, "search")) {
-          throw new Error(
-            `${prefix}: searchable: true but query "${section.query}" has no "search" parameter in its Zod schema`,
-          );
-        }
-        if (
-          section.facets !== undefined &&
-          section.facets.length > 0 &&
-          !schemaAccepts(schema, "filters")
-        ) {
-          throw new Error(
-            `${prefix}: declares facets but query "${section.query}" has no "filters" parameter in its Zod schema — add filters: z.array(z.object({ field: z.string(), op: z.literal("in"), value: z.unknown() })).optional() (or reuse entityListSchema's shape) to the handler's schema.`,
-          );
-        }
+        validateRelatedListSearchable(prefix, section, schema);
+        validateRelatedListFacets(prefix, section, schema);
       }
     }
   }

package/src/engine/boot-validator/query-output-columns.ts

@@ -219,7 +219,8 @@ function checkScreenOutputColumns(
   } else if (
     screen.type === "entityEdit" ||
     screen.type === "actionForm" ||
-    screen.type === "configEdit"
+    screen.type === "configEdit" ||
+    screen.type === "secretMint"
   ) {
     checkEditLayoutOutputColumns(queryHandlers, featureName, screenId, screen.type, screen.layout);
   } else if (screen.type === "dashboard") {

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

@@ -111,7 +111,8 @@ function checkScreenQueryRefs(
   } else if (
     screen.type === "entityEdit" ||
     screen.type === "actionForm" ||
-    screen.type === "configEdit"
+    screen.type === "configEdit" ||
+    screen.type === "secretMint"
   ) {
     checkEditLayoutQueryRefs(queryHandlers, featureName, screenId, screen.type, screen.layout);
   } else if (screen.type === "dashboard") {