@cosmicdrift/kumiko-framework 0.330.2 → 0.332.0

package/dist/db/blind-index-cleanup.d.ts

@@ -3,3 +3,4 @@ import type { DbRunner } from "./connection.js";
 export declare function nullBlindIndexesForSubject(db: DbRunner, features: ReadonlyMap<string, FeatureDefinition>, subjectKey: string): Promise<void>;
 export declare function subjectRowExistsInTenant(db: DbRunner, features: ReadonlyMap<string, FeatureDefinition>, subjectId: string, tenantId: string): Promise<boolean>;
 export declare function recordRowExistsInTenant(db: DbRunner, features: ReadonlyMap<string, FeatureDefinition>, entityName: string, recordId: string, tenantId: string): Promise<boolean>;
+export declare function recordRowOwningTenantId(db: DbRunner, features: ReadonlyMap<string, FeatureDefinition>, entityName: string, recordId: string): Promise<string | undefined>;

package/dist/db/blind-index-cleanup.js

@@ -110,3 +110,15 @@ export async function recordRowExistsInTenant(db, features, entityName, recordId
     const rows = await executeRawQueryRead(db, `SELECT 1 FROM ${quoteIdent(tableName)} WHERE id = $1 AND tenant_id = $2 LIMIT 1`, [recordId, tenantId]);
     return rows.length > 0;
 }
+// Owning tenant of a record subject's row, for callers that must evaluate
+// tenant-scoped policy for the row's real owner (not the acting user's tenant).
+export async function recordRowOwningTenantId(db, features, entityName, recordId) {
+    const entity = findEntityByExactName(features, entityName);
+    if (!entity)
+        return undefined;
+    const tableName = resolveTableName(entityName, entity, undefined);
+    if (!(await tableExists(db, tableName)))
+        return undefined;
+    const rows = await executeRawQueryRead(db, `SELECT tenant_id FROM ${quoteIdent(tableName)} WHERE id = $1 LIMIT 1`, [recordId]);
+    return rows[0]?.tenant_id;
+}

package/dist/db/index.d.ts

@@ -1,5 +1,5 @@
 export { assertExistsIn } from "./assert-exists-in.js";
-export { nullBlindIndexesForSubject, recordRowExistsInTenant, subjectRowExistsInTenant, } from "./blind-index-cleanup.js";
+export { nullBlindIndexesForSubject, recordRowExistsInTenant, recordRowOwningTenantId, subjectRowExistsInTenant, } from "./blind-index-cleanup.js";
 export { collectTableMetas } from "./collect-table-metas.js";
 export { flattenCompoundTypes, rehydrateCompoundTypes } from "./compound-types.js";
 export { seedConfigValues } from "./config-seed.js";

package/dist/db/index.js

@@ -1,5 +1,5 @@
 export { assertExistsIn } from "./assert-exists-in.js";
-export { nullBlindIndexesForSubject, recordRowExistsInTenant, subjectRowExistsInTenant, } from "./blind-index-cleanup.js";
+export { nullBlindIndexesForSubject, recordRowExistsInTenant, recordRowOwningTenantId, subjectRowExistsInTenant, } from "./blind-index-cleanup.js";
 export { collectTableMetas } from "./collect-table-metas.js";
 export { flattenCompoundTypes, rehydrateCompoundTypes } from "./compound-types.js";
 export { seedConfigValues } from "./config-seed.js";

package/dist/db/queries/event-consumer.d.ts

@@ -24,10 +24,11 @@ export type ConsumerDeliveryOutcome = {
     readonly deadLettered: boolean;
     readonly processed: number;
     readonly pendingGaps: readonly PendingGapEntry[];
+    readonly failedEventId: bigint | null;
 };
 export declare function updateConsumerDeliveryOutcome(db: AnyDb, name: string, instanceId: string, outcome: ConsumerDeliveryOutcome): Promise<void>;
 export declare function updateConsumerStatusReturning(db: AnyDb, name: string, instanceId: string, status: "idle" | "disabled"): Promise<Record<string, unknown> | undefined>;
-export declare function advanceConsumerPastEventReturning(db: AnyDb, name: string, instanceId: string, eventId: bigint): Promise<Record<string, unknown> | undefined>;
+export declare function advanceConsumerPastEventReturning(db: AnyDb, name: string, instanceId: string, eventId: bigint, gapToAdd?: PendingGapEntry | null): Promise<Record<string, unknown> | undefined>;
 export declare function resetConsumerForMspRebuild(db: AnyDb, name: string, instanceId: string): Promise<void>;
 export declare function selectConsumerForUpdate(db: AnyDb, name: string, instanceId: string): Promise<Record<string, unknown> | undefined>;
 export declare function updateConsumerRebuildCursor(db: AnyDb, name: string, instanceId: string, lastProcessedEventId: bigint, pendingGaps: readonly PendingGapEntry[]): Promise<void>;

package/dist/db/queries/event-consumer.js

@@ -167,6 +167,7 @@ export async function updateConsumerDeliveryOutcome(db, name, instanceId, outcom
        "rearm_count" = CASE WHEN $5 THEN 0 ELSE "rearm_count" END,
        -- text param + cast: a JS string bound straight to ::jsonb double-encodes under Bun.SQL
        "pending_gaps" = $6::text::jsonb,
+       "last_failed_event_id" = $9,
        "updated_at" = now()
      WHERE "name" = $7 AND "instance_id" = $8`, [
         outcome.cursor,
@@ -177,6 +178,7 @@ export async function updateConsumerDeliveryOutcome(db, name, instanceId, outcom
         JSON.stringify(outcome.pendingGaps),
         name,
         instanceId,
+        outcome.failedEventId,
     ]);
 }
 export async function updateConsumerStatusReturning(db, name, instanceId, status) {
@@ -185,16 +187,21 @@ export async function updateConsumerStatusReturning(db, name, instanceId, status
      RETURNING *`, [status, name, instanceId]));
     return rows[0];
 }
-export async function advanceConsumerPastEventReturning(db, name, instanceId, eventId) {
+export async function advanceConsumerPastEventReturning(db, name, instanceId, eventId, 
+// Ids skipped over between the old cursor and eventId that were not visible yet.
+gapToAdd = null) {
     const rows = (await asRawClient(db).unsafe(`UPDATE "kumiko_event_consumers" SET
        "last_processed_event_id" = $1,
        "status" = 'idle',
        "attempts" = 0,
        "last_error" = NULL,
        "rearm_count" = 0,
+       "last_failed_event_id" = NULL,
+       -- text param + cast: a JS string bound straight to ::jsonb double-encodes under Bun.SQL
+       "pending_gaps" = CASE WHEN $4::text IS NULL THEN "pending_gaps" ELSE "pending_gaps" || $4::text::jsonb END,
        "updated_at" = now()
      WHERE "name" = $2 AND "instance_id" = $3
-     RETURNING *`, [eventId, name, instanceId]));
+     RETURNING *`, [eventId, name, instanceId, gapToAdd === null ? null : JSON.stringify([gapToAdd])]));
     return rows[0];
 }
 export async function resetConsumerForMspRebuild(db, name, instanceId) {
@@ -206,6 +213,7 @@ export async function resetConsumerForMspRebuild(db, name, instanceId) {
        "attempts" = 0,
        "last_error" = NULL,
        "pending_gaps" = '[]'::jsonb,
+       "last_failed_event_id" = NULL,
        "updated_at" = now()`, [name, instanceId]);
 }
 export async function selectConsumerForUpdate(db, name, instanceId) {
@@ -220,6 +228,7 @@ export async function updateConsumerRebuildCursor(db, name, instanceId, lastProc
        "last_error" = NULL,
        -- text param + cast: a JS string bound straight to ::jsonb double-encodes under Bun.SQL
        "pending_gaps" = $2::text::jsonb,
+       "last_failed_event_id" = NULL,
        "updated_at" = now()
      WHERE "name" = $3 AND "instance_id" = $4`, [lastProcessedEventId, JSON.stringify(pendingGaps), name, instanceId]);
 }
@@ -254,6 +263,7 @@ export async function removePendingGapReturning(db, name, instanceId, newPending
        "attempts" = 0,
        "last_error" = NULL,
        "rearm_count" = 0,
+       "last_failed_event_id" = NULL,
        "updated_at" = now()
      WHERE "name" = $2 AND "instance_id" = $3
      RETURNING *`, [JSON.stringify(newPendingGaps), name, instanceId]));

package/dist/engine/boot-validator/action-wiring.js

@@ -38,6 +38,9 @@ export function validateActionWiring(feature) {
         for (const action of screen.toolbarActions ?? []) {
             validateActionNoFunctions(feature.name, screen.id, "toolbarAction", action);
         }
+        if (screen.type === "entityList" && screen.expandableRow !== undefined) {
+            validateColumnsNoFunctions(feature.name, screen.id, "entityList", screen.expandableRow.columns);
+        }
     }
 }
 // EditFieldSpec's visible/readOnly/required are the same FieldCondition DSL

package/dist/engine/boot-validator/config-deps.d.ts

@@ -4,6 +4,7 @@ export declare function validateConfigKeyBounds(feature: FeatureDefinition): voi
 export declare function validateConfigKeyComputed(feature: FeatureDefinition): void;
 export declare function validateConfigKeyRequired(feature: FeatureDefinition): void;
 export declare function validateConfigKeyAllowPerRequest(feature: FeatureDefinition): void;
+export declare function validateConfigKeyOptionsQuery(feature: FeatureDefinition): void;
 export declare function validateConfigKeyBacking(feature: FeatureDefinition): void;
 export declare function validateConfigKeyPiiEncrypted(feature: FeatureDefinition): void;
 export declare function validateConfigReads(features: readonly FeatureDefinition[], allConfigKeys: ReadonlySet<string>): void;

package/dist/engine/boot-validator/config-deps.js

@@ -101,6 +101,30 @@ export function validateConfigKeyAllowPerRequest(feature) {
         }
     }
 }
+// --- Config key optionsQuery compatibility ---
+export function validateConfigKeyOptionsQuery(feature) {
+    for (const [keyName, keyDef] of Object.entries(feature.configKeys)) {
+        const prefix = `[Feature ${feature.name}] Config key "${keyName}"`;
+        if (keyDef.optionsQuery === undefined) {
+            if (keyDef.optionsQueryPayload !== undefined) {
+                throw new Error(`${prefix} has optionsQueryPayload without optionsQuery`);
+            }
+            continue;
+        }
+        if (keyDef.optionsQuery.length === 0) {
+            throw new Error(`${prefix} has an empty optionsQuery`);
+        }
+        if (keyDef.type !== "select") {
+            throw new Error(`${prefix} has optionsQuery but type="${keyDef.type}" — optionsQuery is only valid on select keys`);
+        }
+        if (keyDef.options !== undefined && keyDef.options.length > 0) {
+            throw new Error(`${prefix} declares both options and optionsQuery — pick one`);
+        }
+        if (keyDef.allowPerRequest) {
+            throw new Error(`${prefix} has optionsQuery AND allowPerRequest=true — a per-request value would bypass the option set unchecked`);
+        }
+    }
+}
 // --- Config key storage backing × scope matrix ---
 export function validateConfigKeyBacking(feature) {
     for (const [keyName, keyDef] of Object.entries(feature.configKeys)) {

package/dist/engine/boot-validator/entity-handler.d.ts

@@ -16,6 +16,7 @@ export declare function validateEncryptedFields(feature: FeatureDefinition): boo
 export declare function validateFileFields(feature: FeatureDefinition): boolean;
 export declare function validateReferenceFields(feature: FeatureDefinition, featureMap: ReadonlyMap<string, FeatureDefinition>, queryHandlers: ReadonlyMap<string, QueryHandlerDef>): void;
 export declare function validateEmbeddedFields(feature: FeatureDefinition, featureMap: ReadonlyMap<string, FeatureDefinition>, queryHandlers: ReadonlyMap<string, QueryHandlerDef>): void;
+export declare function validateEntitySelectOptionsQuery(feature: FeatureDefinition): void;
 export declare function validateMultiSelectFields(feature: FeatureDefinition): void;
 export declare function validateImageVariants(feature: FeatureDefinition): void;
 export declare function validateTransitions(feature: FeatureDefinition): void;

package/dist/engine/boot-validator/entity-handler.js

@@ -593,6 +593,26 @@ function validateCheckboxDisplayOptions(field, fieldName, entityName) {
         throw new Error(`MultiSelect field "${fieldName}" on entity "${entityName}" sets maxRows, which is only valid with display: "checkboxes".`);
     }
 }
+export function validateEntitySelectOptionsQuery(feature) {
+    for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
+        for (const [fieldName, field] of Object.entries(entity.fields)) {
+            assertNoSelectOptionsQuery(field, `${entityName}.${fieldName}`, feature.name);
+            if (field.type !== "embedded")
+                continue;
+            for (const [subName, subField] of Object.entries(field.schema ?? {})) {
+                assertNoSelectOptionsQuery(subField, `${entityName}.${fieldName}.${subName}`, feature.name);
+            }
+        }
+    }
+}
+function assertNoSelectOptionsQuery(field, path, featureName) {
+    // @cast-boundary schema-walk — embedded sub-field types don't declare optionsQuery, an untyped author may still set it
+    const { optionsQuery, optionsQueryPayload } = field;
+    const declaresOptionsQuery = optionsQuery !== undefined || optionsQueryPayload !== undefined;
+    if (field.type === "select" && declaresOptionsQuery) {
+        throw new Error(`[Feature ${featureName}] Entity select field "${path}" declares optionsQuery — not supported on entity fields because the stored value would not be validated against the query result. Use static options, or a reference field.`);
+    }
+}
 export function validateMultiSelectFields(feature) {
     for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
         for (const [fieldName, field] of Object.entries(entity.fields)) {

package/dist/engine/boot-validator/index.js

@@ -7,9 +7,9 @@ import { warnOnUniqueAccessRoles } from "./access-roles.js";
 import { validateActionWiring, validateFieldWiring } from "./action-wiring.js";
 import { validateApiExposureMatching, validateExtensionUsages } from "./api-ext.js";
 import { validateFeatureBootChecks } from "./boot-check.js";
-import { validateCircularDeps, validateConfigKeyAllowPerRequest, validateConfigKeyBacking, validateConfigKeyBounds, validateConfigKeyComputed, validateConfigKeyPiiEncrypted, validateConfigKeyRequired, validateConfigReads, warnOnToggleableDependencies, } from "./config-deps.js";
+import { validateCircularDeps, validateConfigKeyAllowPerRequest, validateConfigKeyBacking, validateConfigKeyBounds, validateConfigKeyComputed, validateConfigKeyOptionsQuery, validateConfigKeyPiiEncrypted, validateConfigKeyRequired, validateConfigReads, warnOnToggleableDependencies, } from "./config-deps.js";
 import { collectDetailForScreens } from "./detail-screens.js";
-import { validateDerivedFieldCollisions, validateEmbeddedFields, validateEncryptedFields, validateEntityIndexes, validateExtendSchemaCollisions, validateExtensionPreSaveWiring, validateFileFields, validateHandlerAccess, validateImageVariants, validateLocatedTimestamps, validateMultiSelectFields, validateMultiStreamProjections, validateReferenceFields, validateTransitions, } from "./entity-handler.js";
+import { validateDerivedFieldCollisions, validateEmbeddedFields, validateEncryptedFields, validateEntityIndexes, validateEntitySelectOptionsQuery, validateExtendSchemaCollisions, validateExtensionPreSaveWiring, validateFileFields, validateHandlerAccess, validateImageVariants, validateLocatedTimestamps, validateMultiSelectFields, validateMultiStreamProjections, validateReferenceFields, validateTransitions, } from "./entity-handler.js";
 import { validateEntityListScreens } from "./entity-list-screens.js";
 import { validateGdprStoragePersistence } from "./gdpr-storage.js";
 import { validateGlobalTenancyEntities } from "./global-tenancy.js";
@@ -24,6 +24,7 @@ import { validateQueryRefs } from "./query-refs.js";
 import { validateRecordOwnedSubjects } from "./record-owned.js";
 import { collectScreenQns, collectScreensByShortId, validateScreenShortIdCollisions, validateScreens, } from "./screens.js";
 import { warnOnMissingSecurityBaseline } from "./security-baseline.js";
+import { validateExtensionSelectorPanels } from "./selector-owner-panels.js";
 import { validateTransferGraph } from "./transfer-graph.js";
 import { collectWorkspaceQns, resolveNavAllowlist, validateDefaultWorkspaceUniqueness, validateWorkspaces, } from "./workspaces.js";
 export { validateAppCustomScreenWriteQns } from "./custom-screen-write-qns.js";
@@ -122,6 +123,7 @@ export function validateBoot(rawFeatures, options) {
         validatePiiAndRetention(feature);
         validateRecordOwnedSubjects(feature);
         validateApiExposureMatching(feature, allExposedApis, featureMap);
+        validateEntitySelectOptionsQuery(feature);
         validateEmbeddedFields(feature, featureMap, queryHandlerQns);
         validateMultiSelectFields(feature);
         validateImageVariants(feature);
@@ -139,6 +141,7 @@ export function validateBoot(rawFeatures, options) {
         validateConfigKeyComputed(feature);
         validateConfigKeyAllowPerRequest(feature);
         validateConfigKeyBacking(feature);
+        validateConfigKeyOptionsQuery(feature);
         validateConfigKeyPiiEncrypted(feature);
         validateOwnershipRules(feature, allClaimKeys, knownRoles);
         validateParentRefs(feature, featureMap);
@@ -168,6 +171,7 @@ export function validateBoot(rawFeatures, options) {
     // misleading "no search parameter in its Zod schema" error instead of
     // the clear typo message below.
     validateQueryRefs(features);
+    validateExtensionSelectorPanels(features);
     // Must also run after validateQueryRefs — column/field checks below
     // assume every `query` string already resolves to a registered handler.
     validateQueryOutputColumns(features);

package/dist/engine/boot-validator/projection-list-screens.js

@@ -200,19 +200,24 @@ function validateRelatedListParentFilter(prefix, section, schema, handler, featu
 export function validateRelatedListSectionQueries(features) {
     const queryHandlers = buildQueryHandlerMap(features);
     const featureMap = new Map(features.map((f) => [f.name, f]));
+    const validateSectionQuery = (prefix, section) => {
+        const handler = queryHandlers.get(section.query);
+        const schema = handler?.schema;
+        validateRelatedListSearchable(prefix, section, schema);
+        validateRelatedListFacets(prefix, section, schema);
+        validateRelatedListParentFilter(prefix, section, schema, handler, featureMap);
+    };
     for (const feature of features) {
         for (const screen of Object.values(feature.screens)) {
+            if (screen.type === "entityList" && screen.expandableRow !== undefined) {
+                validateSectionQuery(`[Feature ${feature.name}] Screen "${screen.id}" (entityList) expandableRow "${screen.expandableRow.title}"`, screen.expandableRow);
+            }
             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 handler = queryHandlers.get(section.query);
-                const schema = handler?.schema;
-                validateRelatedListSearchable(prefix, section, schema);
-                validateRelatedListFacets(prefix, section, schema);
-                validateRelatedListParentFilter(prefix, section, schema, handler, featureMap);
+                validateSectionQuery(`[Feature ${feature.name}] Screen "${screen.id}" (${screen.type}) relatedList section "${section.title}"`, section);
             }
         }
     }

package/dist/engine/boot-validator/query-output-columns.js

@@ -62,8 +62,21 @@ function checkProjectionDetailOutputFields(queryHandlers, featureName, screenId,
     };
     if (screen.header !== undefined) {
         checkHeaderField("title", screen.header.title);
-        if (screen.header.subtitle !== undefined)
-            checkHeaderField("subtitle", screen.header.subtitle);
+        const subtitle = screen.header.subtitle;
+        if (typeof subtitle === "string")
+            checkHeaderField("subtitle", subtitle);
+        else if (subtitle !== undefined) {
+            for (const part of subtitle) {
+                if (typeof part === "string") {
+                    checkHeaderField("subtitle", part);
+                    continue;
+                }
+                checkHeaderField("subtitle", part.field);
+                if (part.navigate?.entityId !== undefined) {
+                    checkHeaderField("subtitle", part.navigate.entityId);
+                }
+            }
+        }
         if (screen.header.status !== undefined)
             checkHeaderField("status", screen.header.status);
     }
@@ -139,6 +152,14 @@ function checkScreenOutputColumns(queryHandlers, featureName, screenId, screen)
     if (screen.type === "projectionList") {
         checkProjectionListOutputColumns(queryHandlers, featureName, screenId, screen);
     }
+    else if (screen.type === "entityList") {
+        if (screen.expandableRow !== undefined) {
+            const rowShape = getZodRowShape(queryHandlers.get(screen.expandableRow.query)?.outputSchema);
+            for (const column of screen.expandableRow.columns) {
+                checkColumnField(rowShape, column, (field) => `[Feature ${featureName}] Screen "${screenId}" (entityList) expandableRow "${screen.expandableRow?.title}" column "${field}" is not present in query "${screen.expandableRow?.query}"'s outputSchema — check for a typo, or add a "label" to mark it a virtual/computed column.`);
+            }
+        }
+    }
     else if (screen.type === "projectionDetail") {
         checkProjectionDetailOutputFields(queryHandlers, featureName, screenId, screen);
         checkEditLayoutOutputColumns(queryHandlers, featureName, screenId, "projectionDetail", screen.layout);

package/dist/engine/boot-validator/query-refs.d.ts

@@ -1,2 +1,3 @@
-import type { FeatureDefinition } from "../types/index.js";
+import type { FeatureDefinition, QueryHandlerDef } from "../types/index.js";
+export declare function checkQueryRef(queryHandlers: ReadonlyMap<string, QueryHandlerDef>, query: string, buildPrefix: () => string): void;
 export declare function validateQueryRefs(features: readonly FeatureDefinition[]): void;

package/dist/engine/boot-validator/query-refs.js

@@ -4,7 +4,7 @@ const NOT_REGISTERED_SUFFIX = "is not a registered query-handler. Check the QN s
 function isNonEmptyQueryString(value) {
     return typeof value === "string" && value.length > 0;
 }
-function checkQueryRef(queryHandlers, query, buildPrefix) {
+export function checkQueryRef(queryHandlers, query, buildPrefix) {
     // skip: empty/non-string queries get their own message in screens.ts;
     // a registered query has nothing left to check.
     if (!isNonEmptyQueryString(query) || queryHandlers.has(query))
@@ -44,10 +44,22 @@ function checkDashboardQueryRefs(queryHandlers, featureName, screenId, screen) {
         checkQueryRef(queryHandlers, screen.filter.optionsQuery, () => `[Feature ${featureName}] Screen "${screenId}" (dashboard) filter "${screen.filter?.id}"`);
     }
 }
+function checkFormFieldQueryRefs(queryHandlers, featureName, screenId, screenType, fields) {
+    for (const [fieldName, field] of Object.entries(fields)) {
+        if (field.type !== "select" || field.optionsQuery === undefined)
+            continue;
+        checkQueryRef(queryHandlers, field.optionsQuery, () => `[Feature ${featureName}] Screen "${screenId}" (${screenType}) select field "${fieldName}" optionsQuery`);
+    }
+}
 function checkScreenQueryRefs(queryHandlers, featureName, screenId, screen) {
     if (screen.type === "projectionList") {
         checkQueryRef(queryHandlers, screen.query, () => `[Feature ${featureName}] Screen "${screenId}" (projectionList)`);
     }
+    else if (screen.type === "entityList") {
+        if (screen.expandableRow !== undefined) {
+            checkQueryRef(queryHandlers, screen.expandableRow.query, () => `[Feature ${featureName}] Screen "${screenId}" (entityList) expandableRow "${screen.expandableRow?.title}"`);
+        }
+    }
     else if (screen.type === "projectionDetail") {
         checkQueryRef(queryHandlers, screen.query, () => `[Feature ${featureName}] Screen "${screenId}" (projectionDetail)`);
         checkEditLayoutQueryRefs(queryHandlers, featureName, screenId, "projectionDetail", screen.layout);
@@ -57,6 +69,12 @@ function checkScreenQueryRefs(queryHandlers, featureName, screenId, screen) {
         screen.type === "configEdit" ||
         screen.type === "secretMint") {
         checkEditLayoutQueryRefs(queryHandlers, featureName, screenId, screen.type, screen.layout);
+        if (screen.type !== "entityEdit") {
+            checkFormFieldQueryRefs(queryHandlers, featureName, screenId, screen.type, screen.fields);
+        }
+        if (screen.type === "secretMint" && screen.confirm !== undefined) {
+            checkFormFieldQueryRefs(queryHandlers, featureName, screenId, "secretMint confirm", screen.confirm.fields);
+        }
     }
     else if (screen.type === "dashboard") {
         checkDashboardQueryRefs(queryHandlers, featureName, screenId, screen);
@@ -65,6 +83,11 @@ function checkScreenQueryRefs(queryHandlers, featureName, screenId, screen) {
 export function validateQueryRefs(features) {
     const queryHandlers = buildQueryHandlerMap(features);
     for (const feature of features) {
+        for (const [keyName, keyDef] of Object.entries(feature.configKeys)) {
+            if (keyDef.optionsQuery === undefined)
+                continue;
+            checkQueryRef(queryHandlers, keyDef.optionsQuery, () => `[Feature ${feature.name}] Config key "${keyName}" optionsQuery`);
+        }
         for (const [screenId, screen] of Object.entries(feature.screens)) {
             checkScreenQueryRefs(queryHandlers, feature.name, screenId, screen);
         }

package/dist/engine/boot-validator/screens.d.ts

@@ -1,6 +1,6 @@
 import type { IconKey } from "@cosmicdrift/kumiko-types/nav-icon";
 import type { FeatureDefinition } from "../types/index.js";
-import type { RelatedListToolbarAction, RowAction, RowFieldExtractor, ScreenDefinition, ToolbarAction } from "../types/screen.js";
+import type { DashboardCustomPanel, DashboardScreenPanel, RelatedListToolbarAction, RowAction, RowFieldExtractor, ScreenDefinition, ToolbarAction } from "../types/screen.js";
 export declare function rowFieldExtractorKeys(params: RowFieldExtractor): readonly string[];
 export declare function readsNavigateParamsAsFormPrefill(target: ScreenDefinition, explicitEntityId: string | undefined, sourceScreenEntity: string | undefined): boolean;
 export declare function validateActionHasIcon(featureName: string, screenId: string, screenType: "projectionDetail" | "entityEdit", context: string, action: {
@@ -20,6 +20,8 @@ export declare function validateScreens(feature: FeatureDefinition, featureMap:
     readonly featureName: string;
     readonly screen: ScreenDefinition;
 }>): void;
+export declare function validateDashboardScreenPanel(featureName: string, screenId: string, panel: DashboardScreenPanel, featureMap: ReadonlyMap<string, FeatureDefinition>): void;
+export declare function validateDashboardCustomPanel(featureName: string, screenId: string, panel: DashboardCustomPanel): void;
 export declare function validateColumnRendererForm(featureName: string, screenId: string, column: {
     readonly field: string;
     readonly renderer?: unknown;