@cosmicdrift/kumiko-framework 0.330.2 → 0.332.0

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
@@ -831,6 +942,37 @@ export function validateScreens(feature, featureMap, allWriteHandlerQns, allScre
                     }
                 }
             }
+            if (Array.isArray(screen.header?.subtitle)) {
+                if (screen.header.subtitleHref !== undefined) {
+                    throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) sets header.subtitleHref ` +
+                        `together with a multi-part header.subtitle — subtitleHref only works with the string form.`);
+                }
+                const seenPartFields = new Set();
+                for (const part of screen.header.subtitle) {
+                    const partField = typeof part === "string" ? part : part.field;
+                    if (seenPartFields.has(partField)) {
+                        throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) header.subtitle ` +
+                            `lists field "${partField}" twice.`);
+                    }
+                    seenPartFields.add(partField);
+                    const navigate = typeof part === "string" ? undefined : part.navigate;
+                    if (navigate === undefined)
+                        continue;
+                    if (navigate.screen === undefined && navigate.entity === undefined) {
+                        throw new Error(`[Feature ${feature.name}] Screen "${screenId}" (projectionDetail) header.subtitle part ` +
+                            `"${partField}" navigates with neither "screen" nor "entity" — a tab-only navigate has no link target.`);
+                    }
+                    resolveRowActionNavigateTarget(feature.name, screenId, "projectionDetail", "subtitle part", {
+                        kind: "navigate",
+                        id: partField,
+                        label: partField,
+                        ...(navigate.screen !== undefined ? { screen: navigate.screen } : {}),
+                        ...(navigate.entity !== undefined ? { entity: navigate.entity } : {}),
+                        ...(navigate.entityId !== undefined ? { entityId: navigate.entityId } : {}),
+                        ...(navigate.tab !== undefined ? { tab: navigate.tab } : {}),
+                    }, allScreenQns, navTargetShortIds, screensByShortId, detailForScreens);
+                }
+            }
             for (const section of screen.layout.sections) {
                 const sectionLabel = section.title ?? section.id ?? "(untitled)";
                 if (section.actions !== undefined) {
@@ -876,87 +1018,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)) {
@@ -1048,6 +1128,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 — ` +
@@ -1340,6 +1421,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
@@ -1491,7 +1593,7 @@ const EMBEDDABLE_SCREEN_TYPES = new Set([
     "configEdit",
     "secretsEdit",
 ]);
-function validateDashboardScreenPanel(featureName, screenId, panel, featureMap) {
+export function validateDashboardScreenPanel(featureName, screenId, panel, featureMap) {
     const context = `[Feature ${featureName}] Screen "${screenId}" (dashboard) screen-panel "${panel.id}"`;
     const targetQn = resolveScreenTargetQn(featureName, panel.screen);
     const [targetFeatureName = "", , targetShortId = ""] = targetQn.split(":");
@@ -1523,7 +1625,7 @@ function validateDashboardStatGroupPanel(featureName, screenId, panel, addPanelI
         }
     }
 }
-function validateDashboardCustomPanel(featureName, screenId, panel) {
+export function validateDashboardCustomPanel(featureName, screenId, panel) {
     if (panel.component.react === undefined && panel.component.native === undefined) {
         throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) custom-panel "${panel.id}" has no component — ` +
             `declare a react/native component marker.`);

package/dist/engine/boot-validator/selector-owner-panels.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureDefinition } from "../types/index.js";
+export declare function validateExtensionSelectorPanels(features: readonly FeatureDefinition[]): void;

package/dist/engine/boot-validator/selector-owner-panels.js

@@ -0,0 +1,25 @@
+import { buildQueryHandlerMap } from "./projection-list-screens.js";
+import { checkQueryRef } from "./query-refs.js";
+import { validateDashboardCustomPanel, validateDashboardScreenPanel } from "./screens.js";
+// Owner panels are merged into a dashboard that is built after boot, so the screen and
+// query refs are checked here against the registered features instead.
+export function validateExtensionSelectorPanels(features) {
+    const featureMap = new Map(features.map((feature) => [feature.name, feature]));
+    const queryHandlers = buildQueryHandlerMap(features);
+    for (const feature of features) {
+        for (const selector of feature.extensionSelectors ?? []) {
+            const where = `extensionSelector("${selector.extensionName}")`;
+            for (const panel of selector.panels ?? []) {
+                const context = `[Feature ${feature.name}] ${where} panel "${panel.id}"`;
+                if (panel.kind === "custom") {
+                    validateDashboardCustomPanel(feature.name, where, panel);
+                    continue;
+                }
+                validateDashboardScreenPanel(feature.name, where, panel, featureMap);
+                if (panel.visibleWhen !== undefined) {
+                    checkQueryRef(queryHandlers, panel.visibleWhen.query, () => `${context} visibleWhen`);
+                }
+            }
+        }
+    }
+}

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

@@ -11,6 +11,12 @@ function scopeActions(actions, sourceScreenEntity, implicitParams) {
 function relatedListParentParamField(section) {
     return section.parentFilter?.field ?? section.parentParam ?? "id";
 }
+function subtitlePartNavigates(screen) {
+    const subtitle = screen.header?.subtitle;
+    if (typeof subtitle === "string" || subtitle === undefined)
+        return [];
+    return subtitle.flatMap((part) => typeof part === "string" || part.navigate === undefined ? [] : [part.navigate]);
+}
 function projectionDetailNavigateActions(screen) {
     return [
         ...scopeActions(screen.actions, screen.detailFor),
@@ -23,12 +29,23 @@ function projectionDetailNavigateActions(screen) {
         ...(screen.metrics ?? []).flatMap((metric) => typeof metric === "string" || metric.navigate === undefined
             ? []
             : scopeActions([metric.navigate], undefined)),
+        ...subtitlePartNavigates(screen).flatMap((navigate) => scopeActions([navigate], undefined)),
     ];
 }
 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

@@ -56,6 +56,7 @@ const ELEVATED_ROLES = {
 const MACHINE_WRITE_ROLE = "system";
 const NO_SELECTOR_GATING = {
     pluginsByOwnerGroup: new Map(),
+    ownerPanelsByGroup: new Map(),
     pluginFeatures: new Set(),
     secretQns: new Set(),
 };
@@ -93,6 +94,16 @@ function collectVisibleSelectorOwners(registry, visible) {
     }
     return { ownerGroupByExtension, selectorFeatures };
 }
+function collectOwnerPanelsByGroup(registry, ownerGroupByExtension) {
+    const panelsByGroup = new Map();
+    for (const [extension, ownerGroup] of [...ownerGroupByExtension].sort(([a], [b]) => a.localeCompare(b))) {
+        const panels = registry.getExtensionSelectorPanels(extension);
+        if (panels.length === 0)
+            continue;
+        panelsByGroup.set(ownerGroup, [...(panelsByGroup.get(ownerGroup) ?? []), ...panels]);
+    }
+    return panelsByGroup;
+}
 function countSelectorUsagesByFeature(registry) {
     const usageCountByFeature = new Map();
     for (const [extensionName] of registry.getAllExtensionSelectors()) {
@@ -112,7 +123,9 @@ function planSelectorGating(registry, visible, declaredSecrets, secretsEnabled)
     if (ownerGroupByExtension.size === 0)
         return NO_SELECTOR_GATING;
     const usageCountByFeature = countSelectorUsagesByFeature(registry);
-    const pluginsByOwnerGroup = new Map();
+    const ownerPanelsByGroup = collectOwnerPanelsByGroup(registry, ownerGroupByExtension);
+    // A selector with panels but no gated plugin still becomes a dashboard.
+    const pluginsByOwnerGroup = new Map([...ownerPanelsByGroup.keys()].map((ownerGroup) => [ownerGroup, []]));
     const pluginFeatures = new Set();
     const secretQns = new Set();
     for (const [extension, ownerGroup] of [...ownerGroupByExtension].sort(([a], [b]) => a.localeCompare(b))) {
@@ -135,7 +148,7 @@ function planSelectorGating(registry, visible, declaredSecrets, secretsEnabled)
                 secretQns.add(s.qn);
         }
     }
-    return { pluginsByOwnerGroup, pluginFeatures, secretQns };
+    return { pluginsByOwnerGroup, ownerPanelsByGroup, pluginFeatures, secretQns };
 }
 // A tenant/user-home key with an elevated write role (SystemAdmin on a
 // tenant key, see ELEVATED_ROLES) surfaces the SAME feature under two
@@ -173,7 +186,7 @@ function buildFeatureScreensAndNavs(scope, visible, hub, gating, secretsAccess)
             out.navs.push(buildFeatureNav(scope, feature, ordered, access, hub.declaredTranslationKeys));
             continue;
         }
-        const ownerHub = buildSelectorOwnerDashboard(feature, ordered, access, plugins, hub, secretsAccess);
+        const ownerHub = buildSelectorOwnerDashboard(feature, ordered, access, plugins, gating.ownerPanelsByGroup.get(feature) ?? [], hub, secretsAccess);
         out.screens.push(...ownerHub.screens);
         out.navs.push(buildFeatureNav(scope, feature, ordered, ownerHub.access, hub.declaredTranslationKeys));
         Object.assign(out.translations, ownerHub.translations);
@@ -183,9 +196,20 @@ function buildFeatureScreensAndNavs(scope, visible, hub, gating, secretsAccess)
 function pluginTenantScreenId(plugin) {
     return `${plugin.feature}-tenant`;
 }
+function assertUniquePanelIds(ownerGroup, panels) {
+    const seen = new Set();
+    for (const panel of panels) {
+        if (seen.has(panel.id)) {
+            throw new Error(`Settings dashboard "${ownerGroup}-tenant" has duplicate panel id "${panel.id}" — an ` +
+                `extensionSelector panel id collides with another panel of the same dashboard.`);
+        }
+        seen.add(panel.id);
+    }
+    return panels;
+}
 // Plugin screens keep their `${F}-tenant` ids so consumer title keys stay valid;
 // they are dormant because only this dashboard embeds them.
-function buildSelectorOwnerDashboard(ownerGroup, ownerKeys, ownerAccess, plugins, hub, secretsAccess) {
+function buildSelectorOwnerDashboard(ownerGroup, ownerKeys, ownerAccess, plugins, ownerPanels, hub, secretsAccess) {
     const selectionScreenId = `${ownerGroup}-tenant-selection`;
     const selectionScreen = {
         ...buildScreen(selectionScreenId, "tenant", ownerGroup, ownerKeys, ownerAccess, hub),
@@ -240,11 +264,12 @@ function buildSelectorOwnerDashboard(ownerGroup, ownerKeys, ownerAccess, plugins
         id: `${ownerGroup}-tenant`,
         type: "dashboard",
         description: EXTENSION_SELECTOR_HINT_KEY,
-        panels: [
+        panels: assertUniquePanelIds(ownerGroup, [
             { kind: "screen", id: "selection", screen: selectionScreenId },
+            ...ownerPanels,
             ...configPanels,
             ...secretsPanels,
-        ],
+        ]),
         access,
     };
     return { screens: [dashboard, ...screens], access, translations };
@@ -504,6 +529,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/changeset-changes.js

@@ -67,6 +67,12 @@ export function parseChangesetChanges(markdown, source) {
     let match = BLOCK_RE.exec(markdown);
     while (match !== null) {
         const block = match[1];
+        // BLOCK_RE closes at the first line starting with "-->"; text after it on
+        // that line means a field value contained one and the block ended early.
+        const restOfLine = markdown.slice(match.index + match[0].length).split("\n", 1)[0] ?? "";
+        if (restOfLine.trim() !== "") {
+            throw new Error(`${source}: kumiko-changes block closed early by a line starting with "-->"; field values must not contain such a line`);
+        }
         if (!block)
             throw new Error(`${source}: empty kumiko-changes block`);
         const fields = parseBlock(block, source);

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/entity-handlers.js

@@ -224,7 +224,7 @@ export function defineEntityWriteHandler(name, entity, options) {
     let handler;
     switch (verb) {
         case "create":
-            schema = buildInsertSchema(entity, undefined, excludedFields);
+            schema = buildInsertSchema(entity, undefined, excludedFields, { allowCallerId: true });
             handler = async (event, ctx) => {
                 const { runPreSave } = ctx;
                 // A caller-chosen id (deterministic-id idempotent creates) is only

package/dist/engine/feature-ui-extensions.d.ts

@@ -2,7 +2,7 @@ import { type WebSocketRouteDefinition } from "@cosmicdrift/kumiko-types/websock
 import type { EntityTableMeta } from "../db/entity-table-meta.js";
 import type { FeatureBuilderState } from "./feature-builder-state.js";
 import type { HttpRouteDefinition } from "./types/http-route.js";
-import type { BootCheckFn, EntityProjectionExtension, EscapeHatchDeclaration, HookPhase, LifecycleHookFn, LifecycleHookType, MultiStreamProjectionDefinition, NameOrRef, ProjectionDefinition, RegistrarExtensionDef, SearchPayloadContributorFn, StoreTableOptions, TreeActionDef, TreeActionsHandle, ValidationHookFn } from "./types/index.js";
+import type { BootCheckFn, EntityProjectionExtension, EscapeHatchDeclaration, ExtensionSelectorPanel, HookPhase, LifecycleHookFn, LifecycleHookType, MultiStreamProjectionDefinition, NameOrRef, ProjectionDefinition, RegistrarExtensionDef, SearchPayloadContributorFn, StoreTableOptions, TreeActionDef, TreeActionsHandle, ValidationHookFn } from "./types/index.js";
 import type { ContentCollectionDefinition, NavDefinition } from "./types/nav.js";
 import type { ScreenDefinition } from "./types/screen.js";
 import type { WorkspaceDefinition } from "./types/workspace.js";
@@ -21,7 +21,9 @@ export declare function buildUiExtensionsMethods<TName extends string>(state: Fe
     } & object), entityRef?: NameOrRef, options?: object): void;
     extensionSelector(extensionName: string, key: {
         readonly name: string;
-    } | string): void;
+    } | string, options?: {
+        readonly panels?: readonly ExtensionSelectorPanel[];
+    }): void;
     /**
      * Marker-Deklaration: dieses Feature stellt eine Cross-Feature-API
      * unter dem genannten Namen bereit. Die eigentliche Implementation

package/dist/engine/feature-ui-extensions.js

@@ -2,8 +2,39 @@ import { WEBSOCKET_MAX_CONNECTIONS_PER_USER_LIMIT, WEBSOCKET_MAX_PAYLOAD_BYTES,
 import { bindHookEscapeHatchGrant } from "../pipeline/system-identity-switch.js";
 import { LifecycleHookTypes } from "./constants.js";
 import { resolveName } from "./handler-helpers.js";
-import { isKebabSegment, toKebab } from "./qualified-name.js";
+import { isKebabSegment, isValidQn, qualifyEntityName, toKebab } from "./qualified-name.js";
 import { HookPhases } from "./types/index.js";
+// Builds hooks/extensions/projections/screens/nav/workspace/tables/tree-actions
+// registrar methods.
+// Id the generated owner dashboard reserves for its selector panel.
+const RESERVED_SELECTION_PANEL_ID = "selection";
+function assertSelectorPanelIds(featureName, extensionName, panels) {
+    const seen = new Set();
+    for (const { id } of panels) {
+        if (id === "" || id === RESERVED_SELECTION_PANEL_ID || seen.has(id)) {
+            throw new Error(`[Feature ${featureName}] extensionSelector("${extensionName}") panel id "${id}" must be unique, ` +
+                `non-empty and not "${RESERVED_SELECTION_PANEL_ID}" (reserved for the selector panel).`);
+        }
+        seen.add(id);
+    }
+}
+// The owner dashboard lives in the "config" namespace, so a short screen ref must be
+// qualified against the declaring feature here. Untyped authors can pass other kinds.
+function qualifySelectorPanel(featureName, panel) {
+    if (panel.kind === "custom")
+        return panel;
+    if (panel.kind === "screen") {
+        if ("label" in panel) {
+            throw new Error(`[Feature ${featureName}] extensionSelector screen panel "${panel.id}" must not set a label — ` +
+                `the settings dashboard has no i18n namespace for it; the embedded screen carries its own title.`);
+        }
+        if (panel.screen === "" || isValidQn(panel.screen))
+            return panel;
+        return { ...panel, screen: qualifyEntityName(featureName, "screen", panel.screen) };
+    }
+    throw new Error(`[Feature ${featureName}] extensionSelector panel ${JSON.stringify(panel)} has an unsupported kind — ` +
+        `only "custom" and "screen" panels are allowed.`);
+}
 function isEntityWideHookType(type) {
     return (type === LifecycleHookTypes.postSave ||
         type === LifecycleHookTypes.preDelete ||
@@ -184,13 +215,19 @@ export function buildUiExtensionsMethods(state, name) {
                 options: optionsBag,
             });
         },
-        extensionSelector(extensionName, key) {
+        extensionSelector(extensionName, key, options) {
             if (state.extensionSelectors.some((s) => s.extensionName === extensionName)) {
                 throw new Error(`[Feature ${name}] extensionSelector("${extensionName}") declared twice — ` +
                     `one selector key per extension point.`);
             }
             const qualifiedKey = typeof key === "string" ? key : key.name;
-            state.extensionSelectors.push({ extensionName, qualifiedKey });
+            const panels = options?.panels?.map((panel) => qualifySelectorPanel(name, panel));
+            assertSelectorPanelIds(name, extensionName, panels ?? []);
+            state.extensionSelectors.push({
+                extensionName,
+                qualifiedKey,
+                ...(panels !== undefined && { panels }),
+            });
         },
         /**
          * Marker-Deklaration: dieses Feature stellt eine Cross-Feature-API