@cosmicdrift/kumiko-framework 0.330.0 → 0.331.0

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";
@@ -122,6 +122,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 +140,7 @@ export function validateBoot(rawFeatures, options) {
         validateConfigKeyComputed(feature);
         validateConfigKeyAllowPerRequest(feature);
         validateConfigKeyBacking(feature);
+        validateConfigKeyOptionsQuery(feature);
         validateConfigKeyPiiEncrypted(feature);
         validateOwnershipRules(feature, allClaimKeys, knownRoles);
         validateParentRefs(feature, featureMap);

package/dist/engine/boot-validator/pii-retention.js

@@ -188,16 +188,6 @@ export function validatePiiAndRetention(feature) {
                     // biome-ignore lint/suspicious/noConsole: boot-time dev hint, no logger available yet
                     console.warn(`[kumiko:boot] [Feature ${feature.name}] Entity "${entityName}" retention.strategy="blockDelete" but no field has an anonymize-function. User-Forget cannot anonymize — Forget will return error. Add { anonymize: () => null } or () => "[ANONYMIZED]" to PII fields.`);
                 }
-                else if (!entityHasAnonymizableSubjectField) {
-                    const hasSubjectRef = Object.values(fieldsByName).some((f) => {
-                        const a = f; // @cast-boundary schema-walk
-                        return Boolean(a.subjectRef);
-                    });
-                    if (hasSubjectRef) {
-                        // biome-ignore lint/suspicious/noConsole: boot-time dev hint, no logger available yet
-                        console.warn(`[kumiko:boot] [Feature ${feature.name}] Entity "${entityName}" retention.strategy="blockDelete" with subjectRef-only PII relies on the EXT_USER_DATA delete hook for Art.17 — make sure it is not a no-op.`);
-                    }
-                }
             }
         }
     }

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

@@ -67,6 +67,10 @@ function checkProjectionDetailOutputFields(queryHandlers, featureName, screenId,
         if (screen.header.status !== undefined)
             checkHeaderField("status", screen.header.status);
     }
+    if (screen.recordTitleField !== undefined) {
+        const field = screen.recordTitleField;
+        checkFieldExists(recordShape, field, () => `${prefix} recordTitleField references field "${field}" which is not present in query "${screen.query}"'s outputSchema.`);
+    }
     for (const metric of screen.metrics ?? []) {
         const field = metricField(metric);
         checkFieldExists(recordShape, field, () => `${prefix} metrics references field "${field}" which is not present in query "${screen.query}"'s outputSchema.`);
@@ -135,6 +139,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.js

@@ -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.js

@@ -471,9 +471,28 @@ function validateFormFieldsMap(featureName, screenId, context, fields, allowEmpt
         if (ftype === "money") {
             validateFormMoneyCurrency(featureName, screenId, context, fname, fdef);
         }
+        validateFormSelectOptions(featureName, screenId, context, fname, fdef);
     }
     return fieldNames;
 }
+// Static options XOR optionsQuery on inline-form select fields. The QN
+// existence check lives in query-refs.ts with the other query refs.
+function validateFormSelectOptions(featureName, screenId, context, fieldName, fdef) {
+    if (fdef.type === "select") {
+        const where = `[Feature ${featureName}] Screen "${screenId}" (${context}) select field "${fieldName}"`;
+        if (fdef.optionsQuery !== undefined) {
+            if (fdef.optionsQuery.length === 0) {
+                throw new Error(`${where} has an empty optionsQuery`);
+            }
+            if (fdef.options.length > 0) {
+                throw new Error(`${where} declares both options and optionsQuery — pick one`);
+            }
+        }
+        else if (fdef.optionsQueryPayload !== undefined) {
+            throw new Error(`${where} has optionsQueryPayload without optionsQuery`);
+        }
+    }
+}
 // Fail-closed currency-source gate (fw#2839), the runtime half of the
 // narrowed `FormFieldDefinition` — an untyped JS consumer has no compiler to
 // stop it. An inline form screen has no entity, so a money field there can't
@@ -681,6 +700,98 @@ function validateScreenHasNavArea(feature, screenId, screen, featureMap) {
         `a standalone r.nav() pointing at it, or set dormant: true if it's intentionally reachable ` +
         `only via a direct link/redirect or a consuming app's own r.nav().`);
 }
+// Shared by projectionDetail relatedList sections and entityList.expandableRow:
+// both render a relatedList whose rows come from an arbitrary query.
+function validateRelatedListSection(args) {
+    const { featureName, featureMap, where, section } = args;
+    if (!section.query || typeof section.query !== "string") {
+        throw new Error(`[Feature ${featureName}] ${where} has empty or non-string query.`);
+    }
+    if (section.entity !== undefined) {
+        assertRefTargetRegistered(`[Feature ${featureName}] ${where}`, "entity", section.entity, featureName, featureMap);
+    }
+    for (const col of section.columns) {
+        const normalizedCol = normalizeListColumn(col);
+        if (normalizedCol.refEntity !== undefined) {
+            assertRefTargetRegistered(`[Feature ${featureName}] ${where}`, `column "${normalizedCol.field}" (refEntity)`, normalizedCol.refEntity, featureName, featureMap);
+        }
+    }
+    if (section.rowClick !== undefined) {
+        const targetEntity = section.rowClick.entity;
+        const hasDetailScreen = [...featureMap.values()].some((f) => Object.values(f.screens).some((s) => s.detailFor === targetEntity));
+        if (!hasDetailScreen) {
+            throw new Error(`[Feature ${featureName}] ${where} ` +
+                `rowClick targets entity "${targetEntity}", but no screen declares ` +
+                `detailFor: "${targetEntity}". Add detailFor: "${targetEntity}" to the screen that shows it.`);
+        }
+    }
+    if (section.rowActions !== undefined)
+        validateRelatedListRowActions(args, section.rowActions);
+    if (section.defaultSort !== undefined)
+        validateRelatedListDefaultSort(args, section.defaultSort);
+    if (section.facets !== undefined) {
+        validateListFacets(`[Feature ${featureName}] ${where}`, section.facets, section.columns, featureName, featureMap);
+    }
+    if (section.toolbarActions !== undefined) {
+        validateRelatedListToolbarActions(args, section.toolbarActions);
+    }
+}
+function validateRelatedListRowActions(args, rowActions) {
+    const { featureName, screenId, screenType, where, section, screens, allWriteHandlerQns, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens, } = args;
+    for (const action of rowActions) {
+        if (action.kind === "navigate") {
+            const target = resolveRowActionNavigateTarget(featureName, screenId, screenType, "rowAction", action, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens);
+            validateRowActionNavigateParams(featureName, screenId, screenType, undefined, action, target);
+        }
+        else if (action.kind === "drawer") {
+            validateDrawerTargetAction(featureName, screenId, screenType, "rowAction", action, screens);
+        }
+        else if (!allWriteHandlerQns.has(action.handler)) {
+            throw new Error(`[Feature ${featureName}] ${where} ` +
+                `rowAction "${action.id}" handler "${action.handler}" ` +
+                `is not a registered write-handler. Check the QN spelling (expected ` +
+                `"<feature>:write:<short>") and that the handler is declared via r.writeHandler(...).`);
+        }
+    }
+    // section.rowClick (legacy, navigate-only) and a rowActions entry
+    // marked rowClick:true both claim the row-body click — same
+    // at-most-one constraint as entityList/projectionList's
+    // validateAtMostOneRowClick, just spanning two fields instead of one.
+    const rowClickActionCount = rowActions.filter((a) => a.kind === "navigate" && a.rowClick === true).length;
+    const legacyRowClickCount = section.rowClick !== undefined ? 1 : 0;
+    if (rowClickActionCount + legacyRowClickCount > 1) {
+        throw new Error(`[Feature ${featureName}] ${where} ` +
+            `has both a rowClick and ${rowClickActionCount} rowActions marked ` +
+            `rowClick:true — at most one may fire on a row-body click.`);
+    }
+}
+function validateRelatedListDefaultSort(args, defaultSort) {
+    const { featureName, where, section } = args;
+    const sortField = defaultSort.field;
+    const col = section.columns.find((c) => normalizeListColumn(c).field === sortField);
+    if (col === undefined) {
+        throw new Error(`[Feature ${featureName}] ${where} ` +
+            `defaultSort.field "${sortField}" is not a listed column.`);
+    }
+    if (normalizeListColumn(col).sortable !== true) {
+        throw new Error(`[Feature ${featureName}] ${where} ` +
+            `defaultSort.field "${sortField}" is not sortable. Set sortable: true on ` +
+            `the column or pick another field.`);
+    }
+}
+// Only drawer-kind and navigate actions that set tab are validated here;
+// plain navigate (no tab) and writeHandler toolbarActions have no boot check yet.
+function validateRelatedListToolbarActions(args, toolbarActions) {
+    const { featureName, screenId, screenType, screens, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens, } = args;
+    for (const action of toolbarActions) {
+        if (action.kind === "drawer") {
+            validateDrawerTargetAction(featureName, screenId, screenType, "toolbarAction", action, screens);
+        }
+        if (action.kind === "navigate" && action.tab !== undefined) {
+            resolveRowActionNavigateTarget(featureName, screenId, screenType, "toolbarAction", action, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens);
+        }
+    }
+}
 export function validateScreens(feature, featureMap, allWriteHandlerQns, allScreenQns, allConfigKeyQns, screensByShortId, detailForScreens) {
     // navigate-Targets (rowAction/toolbarAction) dürfen cross-feature zeigen —
     // der Runtime-Router (create-app) löst eine bare screenId app-weit über ALLE
@@ -780,6 +891,10 @@ export function validateScreens(feature, featureMap, allWriteHandlerQns, allScre
                     `and detailFor — the auto-generated "Edit" action navigates using the path's row id, which a ` +
                     `singleton screen never has. Remove detailFor, or declare an explicit "edit" action instead.`);
             }
+            if (screen.recordTitleField !== undefined && screen.header !== undefined) {
+                throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) sets both header and ` +
+                    `recordTitleField — header.title already names the record, so drop recordTitleField.`);
+            }
             if (screen.layout.sections.length === 0) {
                 throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) has an empty sections list — ` +
                     `declare at least one section.`);
@@ -872,87 +987,25 @@ export function validateScreens(feature, featureMap, allWriteHandlerQns, allScre
                     continue;
                 }
                 if (section.kind === "relatedList") {
-                    if (!section.query || typeof section.query !== "string") {
-                        throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" ` +
-                            `(relatedList) has empty or non-string query.`);
-                    }
-                    for (const col of section.columns) {
-                        const normalizedCol = normalizeListColumn(col);
-                        if (normalizedCol.refEntity !== undefined) {
-                            assertRefTargetRegistered(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" (relatedList)`, `column "${normalizedCol.field}" (refEntity)`, normalizedCol.refEntity, feature.name, featureMap);
-                        }
-                    }
                     if (screen.layout.mode === "wizard") {
                         throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" ` +
                             `is kind "relatedList" in a wizard layout — a read-only list is not supported in a ` +
                             `stepped form. Remove mode: "wizard" or drop the relatedList section.`);
                     }
-                    if (section.rowClick !== undefined) {
-                        const targetEntity = section.rowClick.entity;
-                        const hasDetailScreen = [...featureMap.values()].some((f) => Object.values(f.screens).some((s) => s.detailFor === targetEntity));
-                        if (!hasDetailScreen) {
-                            throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" ` +
-                                `(relatedList) rowClick targets entity "${targetEntity}", but no screen declares ` +
-                                `detailFor: "${targetEntity}". Add detailFor: "${targetEntity}" to the screen that shows it.`);
-                        }
-                    }
-                    if (section.rowActions !== undefined) {
-                        for (const action of section.rowActions) {
-                            if (action.kind === "navigate") {
-                                const target = resolveRowActionNavigateTarget(feature.name, screenId, "projectionDetail", "rowAction", action, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens);
-                                validateRowActionNavigateParams(feature.name, screenId, "projectionDetail", undefined, action, target);
-                            }
-                            else if (action.kind === "drawer") {
-                                validateDrawerTargetAction(feature.name, screenId, "projectionDetail", "rowAction", action, feature.screens);
-                            }
-                            else if (!allWriteHandlerQns.has(action.handler)) {
-                                throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section ` +
-                                    `"${section.title}" (relatedList) rowAction "${action.id}" handler "${action.handler}" ` +
-                                    `is not a registered write-handler. Check the QN spelling (expected ` +
-                                    `"<feature>:write:<short>") and that the handler is declared via r.writeHandler(...).`);
-                            }
-                        }
-                        // section.rowClick (legacy, navigate-only) and a rowActions entry
-                        // marked rowClick:true both claim the row-body click — same
-                        // at-most-one constraint as entityList/projectionList's
-                        // validateAtMostOneRowClick, just spanning two fields instead of one.
-                        const rowClickActionCount = section.rowActions.filter((a) => a.kind === "navigate" && a.rowClick === true).length;
-                        const legacyRowClickCount = section.rowClick !== undefined ? 1 : 0;
-                        if (rowClickActionCount + legacyRowClickCount > 1) {
-                            throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" ` +
-                                `(relatedList) has both a rowClick and ${rowClickActionCount} rowActions marked ` +
-                                `rowClick:true — at most one may fire on a row-body click.`);
-                        }
-                    }
-                    if (section.defaultSort !== undefined) {
-                        const sortField = section.defaultSort.field;
-                        const col = section.columns.find((c) => normalizeListColumn(c).field === sortField);
-                        if (col === undefined) {
-                            throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" ` +
-                                `(relatedList) defaultSort.field "${sortField}" is not a listed column.`);
-                        }
-                        if (normalizeListColumn(col).sortable !== true) {
-                            throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) section "${section.title}" ` +
-                                `(relatedList) defaultSort.field "${sortField}" is not sortable. Set sortable: true on ` +
-                                `the column or pick another field.`);
-                        }
-                    }
-                    if (section.facets !== undefined) {
-                        validateListFacets(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) relatedList section "${section.title}"`, section.facets, section.columns, feature.name, featureMap);
-                    }
-                    // Only drawer-kind and navigate actions that set tab are validated
-                    // here — plain navigate (no tab) and writeHandler toolbarActions
-                    // have no boot check yet, same gap as above.
-                    if (section.toolbarActions !== undefined) {
-                        for (const action of section.toolbarActions) {
-                            if (action.kind === "drawer") {
-                                validateDrawerTargetAction(feature.name, screenId, "projectionDetail", "toolbarAction", action, feature.screens);
-                            }
-                            if (action.kind === "navigate" && action.tab !== undefined) {
-                                resolveRowActionNavigateTarget(feature.name, screenId, "projectionDetail", "toolbarAction", action, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens);
-                            }
-                        }
-                    }
+                    validateRelatedListSection({
+                        featureName: feature.name,
+                        featureMap,
+                        screenId,
+                        screenType: "projectionDetail",
+                        where: `Screen "${screenId}" (projectionDetail) section "${section.title}" (relatedList)`,
+                        section,
+                        screens: feature.screens,
+                        allWriteHandlerQns,
+                        allScreenQns,
+                        navTargetShortIds,
+                        screensByShortId,
+                        detailForScreens,
+                    });
                     continue;
                 }
                 if (isWriteFormEditSection(section)) {
@@ -1044,6 +1097,7 @@ export function validateScreens(feature, featureMap, allWriteHandlerQns, allScre
                     throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (configEdit) field "${fname}" has no ` +
                         `\`type\` set. Each field must declare a type (e.g. "text", "number", "select").`);
                 }
+                validateFormSelectOptions(feature.name, screenId, "configEdit", fname, fdef);
             }
             if (screen.layout.sections.length === 0) {
                 throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (configEdit) has an empty sections list — ` +
@@ -1336,6 +1390,27 @@ export function validateScreens(feature, featureMap, allWriteHandlerQns, allScre
                     validateActionFieldRefs(feature.name, screenId, "toolbarAction", action.id, action, fieldNames, rowMeta);
                 }
             }
+            if (screen.expandableRow !== undefined) {
+                const expandableRow = screen.expandableRow;
+                validateRelatedListSection({
+                    featureName: feature.name,
+                    featureMap,
+                    screenId,
+                    screenType: "entityList expandableRow",
+                    where: `Screen "${screenId}" (entityList) expandableRow "${expandableRow.title}"`,
+                    section: expandableRow,
+                    screens: feature.screens,
+                    allWriteHandlerQns,
+                    allScreenQns,
+                    navTargetShortIds,
+                    screensByShortId,
+                    detailForScreens,
+                });
+                // Toolbar actions of the expansion evaluate against the host row.
+                for (const action of expandableRow.toolbarActions ?? []) {
+                    validateActionFieldRefs(feature.name, screenId, "toolbarAction", action.id, action, fieldNames, rowMeta);
+                }
+            }
         }
         else {
             // Same rationale as the columns check: an entityEdit layout with zero

package/dist/engine/boot-validator/url-prefill-fields.js

@@ -28,7 +28,17 @@ function projectionDetailNavigateActions(screen) {
 function navigateActionsOf(screen) {
     switch (screen.type) {
         case "entityList":
-            return scopeActions(screen.rowActions, screen.entity);
+            return [
+                ...scopeActions(screen.rowActions, screen.entity),
+                ...(screen.expandableRow === undefined
+                    ? []
+                    : [
+                        ...scopeActions(screen.expandableRow.rowActions, undefined),
+                        ...scopeActions(screen.expandableRow.toolbarActions, undefined, {
+                            pick: [relatedListParentParamField(screen.expandableRow)],
+                        }),
+                    ]),
+            ];
         case "projectionList":
             return scopeActions(screen.rowActions, undefined);
         case "entityEdit":

package/dist/engine/build-app-schema.js

@@ -394,6 +394,9 @@ function projectField(fieldDef) {
         out["entity"] = def["entity"];
     if (typeof def["labelField"] === "string")
         out["labelField"] = def["labelField"];
+    // fw#2780: author-supplied picker source — without it the client falls back to the list handler.
+    if (typeof def["optionsQuery"] === "string")
+        out["optionsQuery"] = def["optionsQuery"];
     if (typeof def["multiple"] === "boolean")
         out["multiple"] = def["multiple"];
     // MultiSelect: display picks checkboxes vs. combobox in the renderer,

package/dist/engine/build-config-feature-schema.js

@@ -504,6 +504,15 @@ function deriveField(def, selectorPluginIds) {
         case "boolean":
             return createBooleanField();
         case "select":
+            if (def.optionsQuery !== undefined) {
+                return createSelectField({
+                    options: [],
+                    optionsQuery: def.optionsQuery,
+                    ...(def.optionsQueryPayload !== undefined && {
+                        optionsQueryPayload: def.optionsQueryPayload,
+                    }),
+                });
+            }
             return def.options !== undefined && def.options.length > 0
                 ? createSelectField({ options: def.options })
                 : createTextField({ personal: false, reason: "system_metadata" });

package/dist/engine/config-helpers.d.ts

@@ -18,6 +18,8 @@ type ConfigKeyOptions<T extends ConfigKeyType> = {
     encrypted?: boolean;
     piiEncrypted?: T extends "text" ? boolean : never;
     options?: readonly string[];
+    optionsQuery?: T extends "select" ? string : never;
+    optionsQueryPayload?: T extends "select" ? Readonly<Record<string, string | number | boolean>> : never;
     bounds?: T extends "number" ? ConfigBounds : never;
     pattern?: T extends "text" ? {
         regex: string;

package/dist/engine/config-helpers.js

@@ -35,6 +35,14 @@ const SCOPE_DEFAULTS = {
     user: { write: access.all, read: access.all },
 };
 // --- Factory ---
+function optionsQueryProps(opts) {
+    return {
+        ...(opts.optionsQuery !== undefined && { optionsQuery: opts.optionsQuery }),
+        ...(opts.optionsQueryPayload !== undefined && {
+            optionsQueryPayload: opts.optionsQueryPayload,
+        }),
+    };
+}
 function createConfigKey(scope, type, opts = {}) {
     const defaults = SCOPE_DEFAULTS[scope];
     return {
@@ -48,6 +56,7 @@ function createConfigKey(scope, type, opts = {}) {
         ...(opts.encrypted ? { encrypted: true } : {}),
         ...(opts.piiEncrypted ? { piiEncrypted: true } : {}),
         ...(opts.options ? { options: opts.options } : {}),
+        ...optionsQueryProps(opts),
         bounds: opts.bounds, // @cast-boundary schema-walk
         ...(opts.pattern ? { pattern: opts.pattern } : {}),
         computed: opts.computed,

package/dist/engine/index.d.ts

@@ -71,7 +71,7 @@ export { describeWorkflowStepError } from "./steps/describe-workflow-step-error.
 export { ANONYMOUS_ROLE, ANONYMOUS_USER_ID, createAnonymousUser, createSystemUser, SYSTEM_ROLE, SYSTEM_USER_ID, } from "./system-user.js";
 export { type EffectiveFeaturesResolver, findTierResolverUsage, isTierResolverPlugin, TENANT_TIER_RESOLVER_EXT, type TierResolverPlugin, type TrialGate, } from "./tier-resolver-extension.js";
 export { isSystemTenant, isUuid, parseTenantId, SYSTEM_TENANT_ID } from "./types/identifiers.js";
-export type { AccessRule, ActionFormScreenDefinition, ActiveMembership, ActiveMembershipRejection, ActiveMembershipResult, AgentExposure, AgentHandlerHints, AgentRisk, AppContext, AppendEventArgs, AppendEventFn, AuthClaimsContext, AuthClaimsFn, AuthClaimsHookDef, BelongsToRelation, BigIntFieldDef, BooleanFieldDef, CamelToKebab, ClaimKeyDefinition, ClaimKeyHandle, ClaimKeyJsType, ClaimKeyType, ConcurrencyMode, ConfigAccessor, ConfigAccessorFactory, ConfigBacking, ConfigCascade, ConfigCascadeLevel, ConfigDefinition, ConfigEditScreenDefinition, ConfigKeyAccess, ConfigKeyDefinition, ConfigKeyHandle, ConfigKeyType, ConfigMask, ConfigResolver, ConfigScope, ConfigSecretsReader, ConfigSeedDef, ConfigStoredRow, ConfigStoredRowWithSource, ConfigValue, ConfigValueSource, ConfigValueWithSource, ContentCollectionDefinition, CreateSeedOptions, CreateTenantSeedOptions, CreateUserSeedOptions, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardFeedPanel, DashboardFilterDefinition, DashboardListPanel, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DateFieldDef, DecimalFieldDef, DeleteContext, DeriveContext, DerivedFieldDef, DerivedFieldsMap, DerivedValueType, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EntityDefinition, EntityEditScreenDefinition, EntityId, EntityListScreenDefinition, EntityRef, EntityRelations, EscapeHatchAuditSink, EscapeHatchDeclaration, EscapeHatchKind, EscapeHatchReporter, EscapeHatchTarget, EscapeHatchUseEvent, EventDef, ExtensionOptionsArgs, ExtensionOptionsFor, FeatureDefinition, FeatureRegistrar, FieldAccess, FieldCondition, FieldDefinition, FieldFormatRegistry, FieldIconKey, FieldRenderer, FileFieldDef, FilesFieldDef, Findability, FormatSpec, FormWidth, HandlerContext, HasManyRelation, HookMap, ImageFieldDef, ImagesFieldDef, JobBackoff, JobBackoffStrategy, JobContext, JobDefinition, JobHandlerFn, JobTrigger, JobTriggerEvent, JsonbFieldDef, KumikoEntityTypeMap, KumikoEventTypeMap, KumikoExtensionOptionsMap, KumikoHandlerPayloadMap, KumikoHandlerResultMap, LifecycleHookType, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, LongTextFindability, ManyToManyRelation, MemberReader, MetricNavigate, MetricSpec, MspErrorMode, MspErrorPolicy, MultiSelectFieldDef, MultiStreamApplyFn, MultiStreamProjectionDefinition, NameOrRef, NavDefinition, NavIconKey, NotificationDataFn, NotificationDefinition, NotificationRecipientFn, NotificationTemplateFn, NotifyFactory, NotifyFn, NotifyOptions, NotifyPriority, NumberFieldDef, OnDeleteStrategy, OpenToAllAccessRule, OpenToAllDeclaration, OpenToAllPersonalData, ParentRefDef, PersonalAnnotations, PersonalAnnotationsLongText, PersonalAnnotationsNoFind, PersonalSubject, PlatformComponent, PluralForms, PostDeleteHookFn, PostSaveHookFn, PreDeleteHookFn, PreQueryHookFn, PreSaveHookFn, ProjectionDefinition, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, ProjectionTable, QualifiedEventName, QueryEvent, QueryHandlerDef, QueryHandlerFn, RecordHeaderSpec, ReferenceDataDef, Registry, RelationDefinition, ResolvedPiiFlags, RetentionDef, RoleAccessPersonalData, RoleAccessRule, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, SaveContext, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretKeyHandle, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, SelectFieldDef, SessionUser, SessionUserOrigin, StreamHandlerDef, StreamHandlerFn, Subscribe, TargetRef, TenantId, TextFieldDef, ToolbarAction, TranslationEntry, TranslationKeys, TranslationsDef, TranslationValue, TreeAction, TreeActionDef, TreeActionsHandle, TreeChildrenSubscribe, TreeNode, TreeNodeState, UnitKey, UnsafeAppendEventFn, ValidationError, ValidationHookFn, WorkspaceDefinition, WriteEvent, WriteHandlerDef, WriteHandlerFn, WriteResult, } from "./types/index.js";
+export type { AccessRule, ActionFormScreenDefinition, ActiveMembership, ActiveMembershipRejection, ActiveMembershipResult, AgentExposure, AgentHandlerHints, AgentRisk, AppContext, AppendEventArgs, AppendEventFn, AuthClaimsContext, AuthClaimsFn, AuthClaimsHookDef, BelongsToRelation, BigIntFieldDef, BooleanFieldDef, CamelToKebab, ClaimKeyDefinition, ClaimKeyHandle, ClaimKeyJsType, ClaimKeyType, ConcurrencyMode, ConfigAccessor, ConfigAccessorFactory, ConfigBacking, ConfigCascade, ConfigCascadeLevel, ConfigDefinition, ConfigEditScreenDefinition, ConfigKeyAccess, ConfigKeyDefinition, ConfigKeyHandle, ConfigKeyType, ConfigMask, ConfigResolver, ConfigScope, ConfigSecretsReader, ConfigSeedDef, ConfigStoredRow, ConfigStoredRowWithSource, ConfigValue, ConfigValueSource, ConfigValueWithSource, ContentCollectionDefinition, CreateSeedOptions, CreateTenantSeedOptions, CreateUserSeedOptions, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardFeedPanel, DashboardFilterDefinition, DashboardListPanel, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DateFieldDef, DecimalFieldDef, DeleteContext, DeriveContext, DerivedFieldDef, DerivedFieldsMap, DerivedValueType, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EntityDefinition, EntityEditScreenDefinition, EntityId, EntityListExpandableRow, EntityListScreenDefinition, EntityRef, EntityRelations, EscapeHatchAuditSink, EscapeHatchDeclaration, EscapeHatchKind, EscapeHatchReporter, EscapeHatchTarget, EscapeHatchUseEvent, EventDef, ExtensionOptionsArgs, ExtensionOptionsFor, FeatureDefinition, FeatureRegistrar, FieldAccess, FieldCondition, FieldDefinition, FieldFormatRegistry, FieldIconKey, FieldRenderer, FileFieldDef, FilesFieldDef, Findability, FormatSpec, FormWidth, HandlerContext, HasManyRelation, HookMap, ImageFieldDef, ImagesFieldDef, JobBackoff, JobBackoffStrategy, JobContext, JobDefinition, JobHandlerFn, JobTrigger, JobTriggerEvent, JsonbFieldDef, KumikoEntityTypeMap, KumikoEventTypeMap, KumikoExtensionOptionsMap, KumikoHandlerPayloadMap, KumikoHandlerResultMap, LifecycleHookType, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, LongTextFindability, ManyToManyRelation, MemberReader, MetricNavigate, MetricSpec, MspErrorMode, MspErrorPolicy, MultiSelectFieldDef, MultiStreamApplyFn, MultiStreamProjectionDefinition, NameOrRef, NavDefinition, NavIconKey, NotificationDataFn, NotificationDefinition, NotificationRecipientFn, NotificationTemplateFn, NotifyFactory, NotifyFn, NotifyOptions, NotifyPriority, NumberFieldDef, OnDeleteStrategy, OpenToAllAccessRule, OpenToAllDeclaration, OpenToAllPersonalData, ParentRefDef, PersonalAnnotations, PersonalAnnotationsLongText, PersonalAnnotationsNoFind, PersonalSubject, PlatformComponent, PluralForms, PostDeleteHookFn, PostSaveHookFn, PreDeleteHookFn, PreQueryHookFn, PreSaveHookFn, ProjectionDefinition, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, ProjectionTable, QualifiedEventName, QueryEvent, QueryHandlerDef, QueryHandlerFn, RecordHeaderSpec, ReferenceDataDef, Registry, RelationDefinition, ResolvedPiiFlags, RetentionDef, RoleAccessPersonalData, RoleAccessRule, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, SaveContext, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretKeyHandle, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, SelectFieldDef, SessionUser, SessionUserOrigin, StreamHandlerDef, StreamHandlerFn, Subscribe, TargetRef, TenantId, TextFieldDef, ToolbarAction, TranslationEntry, TranslationKeys, TranslationsDef, TranslationValue, TreeAction, TreeActionDef, TreeActionsHandle, TreeChildrenSubscribe, TreeNode, TreeNodeState, UnitKey, UnsafeAppendEventFn, ValidationError, ValidationHookFn, WorkspaceDefinition, WriteEvent, WriteHandlerDef, WriteHandlerFn, WriteResult, } from "./types/index.js";
 export { DEFAULT_CURRENCIES, DEFAULT_LOCALES, HookPhases, isAgentVisibleScreen, isOpenToAllGranted, resolveAgentExposure, } from "./types/index.js";
 export type { AwaitedEventType, PipelineBuildCtx, PipelineCtx, PipelineDef, StepBuilder, StepDef, StepFailureStrategy, StepInstance, StepKind, StepNamespace, StepResolver, } from "./types/step.js";
 export { runValidation } from "./validation.js";

package/dist/engine/project-app-schema-for-roles.js

@@ -54,6 +54,8 @@
 //     buildAppSchema
 //   - WorkspaceSchema.definition.nav — the raw explicit nav-QN list,
 //     verbatim in JSON, distinct from the computed/filtered navMembers
+//   - entityList.createScreen (same-feature target, dropped when not kept)
+//   - entityList.expandableRow (a relatedList: same projection as a relatedList section)
 //   - listScreenId (projectionDetail/entityEdit/actionForm/secretMint/custom —
 //     the breadcrumb "back to list" target). It's serialized, so a visible
 //     screen would otherwise disclose a denied screen's short id. Resolved
@@ -419,16 +421,33 @@ function projectCancelTarget(featureName, cancelTarget, keptScreenQns) {
         return cancelTarget;
     return isScreenTargetKept(featureName, cancelTarget, keptScreenQns) ? cancelTarget : undefined;
 }
-function projectListScreen(screen, feature, indices, keptScreenQns) {
+function dropUnreachableCreateScreen(screen, feature, keptScreenQns) {
+    if (screen.type !== "entityList" || screen.createScreen === undefined)
+        return screen;
+    if (isScreenTargetKept(feature.featureName, screen.createScreen, keptScreenQns))
+        return screen;
+    const { createScreen: _unreachable, ...rest } = screen;
+    return rest;
+}
+function projectListScreen(original, feature, indices, keptScreenQns) {
+    const screen = dropUnreachableCreateScreen(original, feature, keptScreenQns);
     const { rowActions, toolbarActions, ...rest } = screen;
     const nextRowActions = projectRowActionArray(rowActions, feature, indices, keptScreenQns);
     const nextToolbarActions = projectToolbarActionArray(toolbarActions, feature, indices, keptScreenQns);
-    if (nextRowActions === rowActions && nextToolbarActions === toolbarActions)
+    const expandableRow = screen.type === "entityList" ? screen.expandableRow : undefined;
+    const nextExpandableRow = expandableRow === undefined
+        ? undefined
+        : projectRelatedListSection(expandableRow, feature, indices, keptScreenQns);
+    if (nextRowActions === rowActions &&
+        nextToolbarActions === toolbarActions &&
+        nextExpandableRow === expandableRow) {
         return screen;
+    }
     return {
         ...rest,
         ...(nextRowActions !== undefined && { rowActions: nextRowActions }),
         ...(nextToolbarActions !== undefined && { toolbarActions: nextToolbarActions }),
+        ...(nextExpandableRow !== undefined && { expandableRow: nextExpandableRow }),
     };
 }
 function projectProjectionDetailScreen(screen, feature, indices, keptScreenQns) {

package/dist/engine/screen-helpers.js

@@ -23,7 +23,11 @@ export function resolveNavParentScreen(screens, detail, getId) {
     // rowActions, toolbarActions, and drawer-kind actions (which mount inline
     // and have no page of their own) all count as "reached from" this list.
     const navigatesToDetail = (actions) => (actions ?? []).some((a) => (a.kind === "navigate" || a.kind === "drawer") && a.screen === detailScreenId);
+    // The create button of an entityList navigates to its createScreen, so the
+    // list is that screen's parent just like for a rowAction target.
     const listFromRowAction = screens.find((s) => {
+        if (s.type === "entityList" && s.createScreen === detailScreenId)
+            return true;
         if (s.type !== "entityList" && s.type !== "projectionList")
             return false;
         return navigatesToDetail(s.rowActions) || navigatesToDetail(s.toolbarActions);

package/dist/engine/types/index.d.ts

@@ -17,7 +17,7 @@ export type { ContentCollectionDefinition, NavDefinition, NavIconKey, } from "@c
 export type { FromRule, FromRuleKind, OwnershipClause, OwnershipMap, OwnershipRef, OwnershipRule, SqlFragment, WhereRule, WhereRuleContext, } from "@cosmicdrift/kumiko-types/ownership";
 export type { EntityProjectionExtension, MspErrorMode, MspErrorPolicy, MultiStreamApplyFn, MultiStreamProjectionDefinition, ProjectionDefinition, ProjectionTable, SingleStreamApplyFn, } from "@cosmicdrift/kumiko-types/projection";
 export type { BelongsToRelation, EntityRelations, HasManyRelation, ManyToManyRelation, RelationDefinition, } from "@cosmicdrift/kumiko-types/relations";
-export type { ActionFormScreenDefinition, ConfigEditScreenDefinition, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardFeedPanel, DashboardFilterDefinition, DashboardListPanel, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EditWriteFormSection, EntityEditScreenDefinition, EntityListScreenDefinition, FieldCondition, FieldFormatRegistry, FieldRenderer, FormatSpec, FormWidth, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, MetricNavigate, MetricSpec, PlatformComponent, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, RecordHeaderSpec, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, ToolbarAction, UnitKey, } from "@cosmicdrift/kumiko-types/screen";
+export type { ActionFormScreenDefinition, ConfigEditScreenDefinition, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardFeedPanel, DashboardFilterDefinition, DashboardListPanel, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EditWriteFormSection, EntityEditScreenDefinition, EntityListExpandableRow, EntityListScreenDefinition, FieldCondition, FieldFormatRegistry, FieldRenderer, FormatSpec, FormWidth, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, MetricNavigate, MetricSpec, PlatformComponent, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, RecordHeaderSpec, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, ToolbarAction, UnitKey, } from "@cosmicdrift/kumiko-types/screen";
 export { metricField } from "@cosmicdrift/kumiko-types/screen";
 export type { TargetRef } from "@cosmicdrift/kumiko-types/target-ref";
 export type { Subscribe, TreeAction, TreeActionDef, TreeActionsHandle, TreeChildrenSubscribe, TreeNode, TreeNodeState, } from "@cosmicdrift/kumiko-types/tree-node";

package/dist/i18n/required-surface-keys.js

@@ -107,6 +107,30 @@ function pushToolbarActionKeys(out, action) {
     // toolbar button AND the Drawer title, see ToolbarDrawerHost) is
     // already pushed above.
 }
+function pushRelatedListSectionKeys(out, section) {
+    pushKey(out, section.title);
+    pushKey(out, section.description);
+    pushKey(out, section.itemNoun);
+    for (const col of section.columns) {
+        const normalized = normalizeListColumn(col);
+        if (normalized.label !== undefined)
+            pushKey(out, normalized.label);
+    }
+    for (const action of section.rowActions ?? [])
+        pushRowActionKeys(out, action);
+}
+function pushExpandableRowKeys(out, section) {
+    pushRelatedListSectionKeys(out, section);
+    for (const action of section.actions ?? [])
+        pushRowActionKeys(out, action);
+    for (const action of section.toolbarActions ?? [])
+        pushToolbarActionKeys(out, action);
+    pushKey(out, section.emptyState?.title);
+    pushKey(out, section.emptyState?.description);
+    if (section.emptyState?.action !== undefined) {
+        pushRowActionKeys(out, section.emptyState.action);
+    }
+}
 export function requiredKeysFromScreen(featureName, screen, options = {}) {
     const { treatDotFormAsKey = false } = options;
     const out = new Set();
@@ -129,6 +153,8 @@ export function requiredKeysFromScreen(featureName, screen, options = {}) {
                 pushRowActionKeys(out, action);
             for (const action of list.toolbarActions ?? [])
                 pushToolbarActionKeys(out, action);
+            if (list.expandableRow !== undefined)
+                pushExpandableRowKeys(out, list.expandableRow);
             break;
         }
         case "projectionList": {
@@ -301,16 +327,7 @@ export function requiredKeysFromScreen(featureName, screen, options = {}) {
                     continue;
                 }
                 if (section.kind === "relatedList") {
-                    pushKey(out, section.title);
-                    pushKey(out, section.description);
-                    pushKey(out, section.itemNoun);
-                    for (const col of section.columns) {
-                        const normalized = normalizeListColumn(col);
-                        if (normalized.label !== undefined)
-                            pushKey(out, normalized.label);
-                    }
-                    for (const action of section.rowActions ?? [])
-                        pushRowActionKeys(out, action);
+                    pushRelatedListSectionKeys(out, section);
                     continue;
                 }
                 if (isWriteFormEditSection(section)) {

package/dist/ui-types/index.d.ts

@@ -9,7 +9,7 @@ export type { BooleanFieldDef, DateFieldDef, EmbeddedDerivedCellDef, EntityDefin
 export type { AccessRule, OpenToAllAccessRule, OpenToAllDeclaration, OpenToAllPersonalData, RoleAccessPersonalData, RoleAccessRule, } from "../engine/types/handlers.js";
 export { isOpenToAllGranted, isUiAccessGranted } from "../engine/types/handlers.js";
 export type { IconKey, NavDefinition, NavIconKey } from "../engine/types/nav.js";
-export type { ActionFormRedirect, ActionFormScreenDefinition, ConfigEditScreenDefinition, CustomScreenDefinition, CustomScreenRoute, DashboardChartKind, DashboardChartPanel, DashboardChartTone, DashboardCustomPanel, DashboardFeedPanel, DashboardFilterDefinition, DashboardListPanel, DashboardPanelDefinition, DashboardPanelEmptyState, DashboardPanelQueryOptions, DashboardPanelSpan, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScopeDefinition, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DashboardTimeRangeDefinition, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EditWriteFormSection, EntityEditScreenDefinition, EntityListScreenDefinition, FieldCondition, FieldIconKey, FieldRenderer, FormWidth, ListBadgeTone, ListColumnDisplay, ListColumnSpec, ListFacetSpec, ListSortSpec, MetricNavigate, MetricSpec, PlatformComponent, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, RelatedListToolbarAction, RowAction, RowActionDrawer, RowActionNavigate, RowActionWriteHandler, RowFieldExtractor, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenSlots, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, ToolbarAction, } from "../engine/types/screen.js";
+export type { ActionFormRedirect, ActionFormScreenDefinition, ConfigEditScreenDefinition, CustomScreenDefinition, CustomScreenRoute, DashboardChartKind, DashboardChartPanel, DashboardChartTone, DashboardCustomPanel, DashboardFeedPanel, DashboardFilterDefinition, DashboardListPanel, DashboardPanelDefinition, DashboardPanelEmptyState, DashboardPanelQueryOptions, DashboardPanelSpan, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScopeDefinition, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DashboardTimeRangeDefinition, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EditWriteFormSection, EntityEditScreenDefinition, EntityListExpandableRow, EntityListScreenDefinition, FieldCondition, FieldIconKey, FieldRenderer, FormWidth, ListBadgeTone, ListColumnDisplay, ListColumnSpec, ListFacetSpec, ListSortSpec, MetricNavigate, MetricSpec, PlatformComponent, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, RelatedListToolbarAction, RowAction, RowActionDrawer, RowActionNavigate, RowActionWriteHandler, RowFieldExtractor, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenSlots, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, ToolbarAction, } from "../engine/types/screen.js";
 export { metricField } from "../engine/types/screen.js";
 export type { TargetRef } from "../engine/types/target-ref.js";
 export type { TreeAction, TreeNode, TreeNodeState } from "../engine/types/tree-node.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.330.0",
+  "version": "0.331.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -206,8 +206,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-http": "0.330.0",
-    "@cosmicdrift/kumiko-types": "0.330.0",
+    "@cosmicdrift/kumiko-http": "0.331.0",
+    "@cosmicdrift/kumiko-types": "0.331.0",
     "bullmq": "^5.76.7",
     "bun-types": "^1.3.13",
     "hono": "^4.13.1",
@@ -223,7 +223,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.330.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.331.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/changes.json

@@ -1,4 +1,24 @@
 [
+  {
+    "version": "0.331.0",
+    "type": "fix",
+    "title": "A reference field's optionsQuery now reaches the client schema, so the picker uses the declared handler",
+    "detail": "`ReferenceFieldDef.optionsQuery` was dropped by the client-schema projection, so the picker ignored the declared handler and fell back to the entity's list handler. The projection now keeps it.",
+    "migration": "No code change needed."
+  },
+  {
+    "version": "0.331.0",
+    "type": "improvement",
+    "title": "Select fields in configEdit and actionForm screens and select config keys can load their options from a query (optionsQuery)",
+    "detail": "A `select` config key and a `select` field on configEdit and actionForm screens accept `optionsQuery` (a query QN returning `{ rows: { value, label }[] }`) plus an optional static `optionsQueryPayload`. The Settings-Hub derives the field from the config key, the renderer mounts the query and shows the returned labels as they are. The boot validator rejects dead QNs, static `options` together with `optionsQuery`, `allowPerRequest` keys, and `optionsQuery` on entity fields. The write side does not check the value against the query result.",
+    "migration": "No code change needed. Existing select fields and config keys keep their static options."
+  },
+  {
+    "version": "0.330.2",
+    "type": "fix",
+    "title": "createScreen role projection without a type assertion (no behaviour change)",
+    "detail": "Internal cleanup of the createScreen role projection added in the previous release; behaviour is unchanged."
+  },
   {
     "version": "0.330.0",
     "type": "improvement",