@phis/ui 0.2.1 → 0.3.0

package/plugins/runtime-modules/descriptor-compiler.js

@@ -1,16 +1,20 @@
 import { isPhiCmsAreaKey, resolvePhiCmsAreaMask, } from "../../constants/cms-areas";
+import { collectPhiTourDefinitionErrors } from "../../types/tours";
 import { PhiCmsPageType, PhiCmsRegionType, PhiCmsStatus } from "../../constants/phi-cms";
 import { PhiCmsLayoutType } from "../../constants/cms-layout-type-keys";
 import { createPhiPresetCmsInstanceId, createPhiPresetCmsPageId, isPhiCmsInstanceId, readPhiCmsInstanceIdDescriptor, } from "../../types/cms-instance-id";
+import { resolvePhiRuntimeModuleSourceLocale } from "../../types/runtime-module-locale";
 import { canPhiViewerAccess, PHI_VIEWER_ACCESS_ANYONE, } from "../../types/access";
 import { mergePhiCmsShellTrees, omitPhiCmsShellCompositionNodes, } from "./shell-tree-composition";
 import { resolvePhiRuntimeModuleAreaRoutePath } from "../../helpers/runtime-module-route-path";
 import { choosePhiAreaRootApplicant, orderPhiAreaPathClaimsByCover, isPhiAssignablePublicRoutePath, } from "../../helpers/cms-area-config";
 import { resolvePhiLayoutCreationPreset } from "../../helpers/cms-layout-defaults";
+import { PHI_DIALOG_BLEED_BODY_CONFIG, PHI_DIALOG_BODY_CONFIG, PHI_DIALOG_COMMANDS_CONFIG, } from "../../helpers/cms-dialog";
+import { PhiCmsWidgetType } from "../../constants/cms-widget-types";
 import { buildPhiBasePageLayoutNode, PHI_BASE_PAGE_LAYOUT_NODE_ID, } from "../../components/regions/presets/phi-base-page-layout";
+import { concatPhiCmsTreeControllerSettings } from "../../helpers/cms-tree-controller-settings";
 const PHI_CMS_REGION_TYPE_VALUES = new Set(Object.values(PhiCmsRegionType));
 const PHI_ROUTE_PARAMETER_PATTERN = /^:[A-Za-z][A-Za-z0-9_]*$/;
-const PHI_ROUTE_MOUNT_KEY_PATTERN = /^[a-z][a-z0-9-]*$/;
 const PHI_NAVIGATION_ANCHORS = new Set([
     "start",
     "main",
@@ -67,17 +71,10 @@ export function normalizePhiCmsRoutePath(value) {
  * the Module's own, so it keeps the address it asks for.
  *
  * The rule itself is `resolvePhiRuntimeModuleAreaRoutePath`, shared with everything that links to a
- * Module route rather than serves one; what this function adds is the Area mount check and the
- * insistence that a declared path arrives normalized.
+ * Module route rather than serves one; what this function adds is the insistence that a declared path
+ * arrives normalized.
  */
-function resolvePhiCmsNamespacedRouteDescriptor(descriptor, areaDefinition) {
-    if (descriptor.mount) {
-        const mount = (areaDefinition.routeMounts ?? []).find((candidate) => candidate.mountKey === descriptor.mount?.mountKey);
-        if (!mount) {
-            throw new Error(`${descriptor.ownerModuleId}/${descriptor.presetKey}: Area "${descriptor.area}" ` +
-                `does not declare route mount "${descriptor.mount.mountKey}".`);
-        }
-    }
+function resolvePhiCmsNamespacedRouteDescriptor(descriptor) {
     if (descriptor.area === "public" || descriptor.path === "/") {
         return descriptor;
     }
@@ -98,6 +95,22 @@ export function compilePhiCmsRoutePattern(descriptor) {
     }
     const segments = path.split("/").filter(Boolean);
     const dynamicSegments = segments.filter((segment) => segment.startsWith(":"));
+    /*
+     * A Tour is offered only on a route without parameters (server-helpers/cms-request.ts), so one on a
+     * dynamic route would be dead weight that looks configured.
+     */
+    if (descriptor.tour) {
+        const tourErrors = [
+            ...collectPhiTourDefinitionErrors(descriptor.tour),
+            ...(dynamicSegments.length > 0 ? ["a Tour is not offered on a route with a parameter."] : []),
+            ...(descriptor.tour.id.startsWith(`${descriptor.ownerModuleId}/`)
+                ? []
+                : [`Tour id "${descriptor.tour.id}" is not in the owning Module's namespace.`]),
+        ];
+        if (tourErrors.length > 0) {
+            throw new Error(`${descriptor.ownerModuleId}/${descriptor.presetKey}: ${tourErrors.join(" ")}`);
+        }
+    }
     if (dynamicSegments.length > 1) {
         throw new Error(`${descriptor.ownerModuleId}/${descriptor.presetKey}: a route may contain at most one dynamic segment.`);
     }
@@ -220,28 +233,6 @@ function assertAreaDefinitions(areaDefinitions, catalog) {
                 }
             }
         }
-        const routeMountKeys = new Set();
-        for (const mount of definition.routeMounts ?? []) {
-            if (!PHI_ROUTE_MOUNT_KEY_PATTERN.test(mount.mountKey) ||
-                routeMountKeys.has(mount.mountKey)) {
-                throw new Error(`Area "${definition.area}" declares invalid or duplicate route mount "${mount.mountKey}".`);
-            }
-            routeMountKeys.add(mount.mountKey);
-            const surface = (definition.navigationSurfaces ?? []).find((candidate) => candidate.navKey === mount.navKey);
-            if (!surface) {
-                throw new Error(`Area "${definition.area}" route mount "${mount.mountKey}" references ` +
-                    `unknown navigation surface "${mount.navKey}".`);
-            }
-            if (!(surface.exportedItemKeys ?? []).includes(mount.parentItemKey)) {
-                throw new Error(`Area "${definition.area}" route mount "${mount.mountKey}" parent ` +
-                    `"${mount.parentItemKey}" is not exported.`);
-            }
-            const parent = findNavigationItemDescriptor(surface.items, mount.parentItemKey);
-            if (!parent || parent.routePresetKey) {
-                throw new Error(`Area "${definition.area}" route mount "${mount.mountKey}" parent ` +
-                    `"${mount.parentItemKey}" must be a navigation container.`);
-            }
-        }
         definitionsByArea.set(definition.area, definition);
     }
     return definitionsByArea;
@@ -263,7 +254,9 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
     const routesByArea = new Map();
     const themeByKey = new Map();
     const themeBlockByKey = new Map();
+    const sourceLocaleByModuleId = new Map();
     for (const [moduleId, entry] of catalog) {
+        sourceLocaleByModuleId.set(moduleId, resolvePhiRuntimeModuleSourceLocale(entry.definition));
         const descriptorKeys = new Set();
         const registerIdentity = (presetKey) => {
             normalizeRequiredKey(presetKey, `${moduleId} preset key`);
@@ -339,7 +332,7 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
             if (!entry.definition.eligibleAreas.includes(descriptor.area)) {
                 throw new Error(`${moduleId}/${descriptor.presetKey}: owner module is not eligible for Area "${descriptor.area}".`);
             }
-            const resolvedDescriptor = resolvePhiCmsNamespacedRouteDescriptor(descriptor, areaDefinition);
+            const resolvedDescriptor = resolvePhiCmsNamespacedRouteDescriptor(descriptor);
             const compiled = compilePhiCmsRoutePattern(resolvedDescriptor);
             routeByIdentity.set(identity, resolvedDescriptor);
             routeByPageId.set(createPhiPresetCmsPageId({ ownerModuleId: moduleId, presetKey: descriptor.presetKey }), resolvedDescriptor);
@@ -504,7 +497,13 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
             // What still needs an export is a *reference*: `before`, `after`, and `parentItemKey` name someone
             // else's item, and a named item is public API that its owner has to promise to keep.
             const itemKeys = collectNavigationItemKeys([injection.item], `${contributionLabel}/${injection.navKey}`);
-            const allSurfaceKeys = allInjectionKeysBySurface.get(injection.navKey) ?? new Set();
+            /*
+             * Seeded with the surface's own keys: an injected key that equals a base item's is the same
+             * collision as two injections sharing one, and refusing it here is what keeps every read of the
+             * surface from refusing it instead (`registerNode`).
+             */
+            const allSurfaceKeys = allInjectionKeysBySurface.get(injection.navKey)
+                ?? new Set(collectNavigationItemKeys(surface.items, surface.navKey));
             for (const itemKey of itemKeys) {
                 if (allSurfaceKeys.has(itemKey)) {
                     throw new Error(`${injection.navKey}: duplicate injected item key "${itemKey}".`);
@@ -521,6 +520,41 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
             visitNavigationRouteReferences([injection.item], contributorId, contributionArea, `${contributionLabel}/${injection.navKey}`);
         }
     }
+    /*
+     * Every item's parent on a surface, base items and injected ones alike, read once per surface. What
+     * `before` and `after` need to know: the item they name has to stand beside them, under the same
+     * parent, or the read of the surface finds no such sibling and refuses the whole surface.
+     */
+    const navigationParentsBySurface = new Map();
+    const readNavigationParents = (area, surface) => {
+        const surfaceKey = `${area}\u001f${surface.navKey}`;
+        const known = navigationParentsBySurface.get(surfaceKey);
+        if (known) {
+            return known;
+        }
+        const parents = new Map();
+        const visit = (items, parent) => {
+            for (const item of items) {
+                parents.set(item.itemKey, parent);
+                visit(item.children ?? [], item.itemKey);
+            }
+        };
+        visit(surface.items, null);
+        for (const contribution of navigationContributions) {
+            if (contribution.area !== area || contribution.injection.navKey !== surface.navKey) {
+                continue;
+            }
+            const placement = contribution.injection.anchor !== undefined
+                ? surface.anchors?.[contribution.injection.anchor] ?? null
+                : null;
+            const parent = placement
+                ? placement.parentItemKey
+                : "parentItemKey" in contribution.injection ? contribution.injection.parentItemKey ?? null : null;
+            visit([contribution.injection.item], parent);
+        }
+        navigationParentsBySurface.set(surfaceKey, parents);
+        return parents;
+    };
     // Anchors are checked once every injection key is known, so a Module may anchor on its own item as
     // well as on an exported base one -- which is what lets a Module contribute a small subtree.
     for (const { ownerModuleId: contributorId, area: contributionArea, label: contributionLabel, injection } of navigationContributions) {
@@ -544,6 +578,15 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
         assertAnchor(injection.parentItemKey, "parent item");
         assertAnchor(injection.before, "before anchor");
         assertAnchor(injection.after, "after anchor");
+        const siblingAnchor = injection.before ?? injection.after;
+        if (siblingAnchor != null) {
+            const parents = readNavigationParents(contributionArea, surface);
+            const expectedParent = injection.parentItemKey ?? null;
+            if (parents.get(siblingAnchor) !== expectedParent) {
+                throw new Error(`${contributionLabel}: ${injection.before ? "before" : "after"} anchor "${siblingAnchor}" is ` +
+                    `not a sibling under "${expectedParent ?? "root"}".`);
+            }
+        }
     }
     return {
         areaDefinitions: definitionsByArea,
@@ -556,6 +599,7 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
         routesByArea,
         themeByKey,
         themeBlockByKey,
+        sourceLocaleByModuleId,
     };
 }
 const descriptorCatalogByRuntimeCatalog = new WeakMap();
@@ -713,11 +757,17 @@ export function compilePhiCmsActiveRouteTable({ catalog, area, activeModuleIds,
  * What an item points at, if anything currently answers there.
  *
  * Reading a navigation surface may not fail. An item can name a route that no longer answers -- a Module
- * switched off, a path the Module lost when another one took it over -- and the honest response is the
- * one already given to a route the viewer may not reach: the entry is not shown. Refusing belongs to the
- * write that produced the state, not to every read afterwards.
+ * switched off, a root application the Site did not answer -- and the honest response is the one already
+ * given to a route the viewer may not reach: the entry is not shown. Refusing belongs to the write that
+ * produced the state, not to every read afterwards.
+ *
+ * Answered from the Area's active route table and not from the catalog: the table holds the address the
+ * route answers on *this* Site -- a Public path the Site reassigned, a root slot it awarded -- and only
+ * the routes that answer at all. Reading the catalog's path here sent the Auth Module's header entry to
+ * `/register` after the Site had moved registration to `/signup`, and kept a root applicant the Site had
+ * turned down in the sidebar, linking `/`.
  */
-function resolveNavigationTarget(catalog, activeRouteIdentityKeys, ownerModuleId, routePresetKey, overlay) {
+function resolveNavigationTarget(routeTable, ownerModuleId, routePresetKey, overlay) {
     if (overlay) {
         // No path and no lookup against the route table: the item opens something that is already in the
         // Area tree. Ownership was checked when the surface was compiled.
@@ -731,8 +781,8 @@ function resolveNavigationTarget(catalog, activeRouteIdentityKeys, ownerModuleId
     if (!routePresetKey) {
         return null;
     }
-    const route = resolvePhiCmsRoutePresetByIdentity(catalog, ownerModuleId, routePresetKey);
-    if (!route || !activeRouteIdentityKeys.has(buildPhiCmsPresetIdentityKey(ownerModuleId, routePresetKey))) {
+    const route = routeTable.byPageId.get(createPhiPresetCmsPageId({ ownerModuleId, presetKey: routePresetKey }));
+    if (!route) {
         return null;
     }
     return {
@@ -742,11 +792,15 @@ function resolveNavigationTarget(catalog, activeRouteIdentityKeys, ownerModuleId
         path: route.path,
     };
 }
-function buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, navKey, ownerModuleId, descriptor, injection) {
-    const target = resolveNavigationTarget(catalog, activeRouteIdentityKeys, ownerModuleId, descriptor.routePresetKey, descriptor.overlayPresetKey && descriptor.overlayNodeKey
+function buildResolvedNavigationNode(catalog, routeTable, navKey, ownerModuleId, descriptor, injection) {
+    const target = resolveNavigationTarget(routeTable, ownerModuleId, descriptor.routePresetKey, descriptor.overlayPresetKey && descriptor.overlayNodeKey
         ? { presetKey: descriptor.overlayPresetKey, nodeKey: descriptor.overlayNodeKey }
         : null);
-    const intrinsicChildren = (descriptor.children ?? []).map((child) => buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, navKey, ownerModuleId, child, null));
+    const intrinsicChildren = (descriptor.children ?? []).map((child) => buildResolvedNavigationNode(catalog, routeTable, navKey, ownerModuleId, child, null));
+    const sourceLocale = catalog.sourceLocaleByModuleId.get(ownerModuleId);
+    if (!sourceLocale) {
+        throw new Error(`${navKey}: Module "${ownerModuleId}" is not in the descriptor catalog.`);
+    }
     return {
         item: {
             id: createPhiPresetCmsInstanceId({
@@ -759,7 +813,7 @@ function buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, navKey, o
             // An entry that sends is a link in the sense that matters here: it is chosen, and something
             // happens. Only an entry that neither goes nor sends is a container.
             kind: target || descriptor.signalRoutes?.emits?.length ? "link" : "container",
-            label: descriptor.label,
+            label: { ...descriptor.label, sourceLocale },
             ...(descriptor.icon ? { icon: descriptor.icon } : {}),
             ...(descriptor.accessPolicy ? { accessPolicy: descriptor.accessPolicy } : {}),
             ...(descriptor.signalRoutes?.emits?.length
@@ -859,7 +913,7 @@ function orderNavigationSiblings(intrinsic, injected, parentItemKey) {
     }
     return [...ordered, ...trailing];
 }
-export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeModuleIds, viewer, }) {
+export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeModuleIds, routeTable, viewer, }) {
     const definition = catalog.areaDefinitions.get(area);
     if (!definition) {
         throw new Error(`Area "${area}" is not declared.`);
@@ -867,17 +921,18 @@ export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeMod
     if (!activeModuleIds.has(definition.baseModuleId)) {
         throw new Error(`Area "${area}" base module "${definition.baseModuleId}" is not active.`);
     }
+    if (routeTable.area !== area) {
+        throw new Error(`Area "${area}" was handed the route table of Area "${routeTable.area}".`);
+    }
     /*
      * Which routes exist, and nothing about who is reading.
      *
-     * A route is in or out by Module selection alone. An entry may still hide from one reader -- that is
+     * A route is in or out by Module selection and the Site's answers alone -- the active route table is
+     * that set, with the address each route answers on. An entry may still hide from one reader -- that is
      * the next block, and it is the entry's own statement -- but the set of addresses this Area answers is
      * one set (ACCESS.md).
      */
-    const activeRoutes = (catalog.routesByArea.get(area) ?? [])
-        .map(({ descriptor }) => descriptor)
-        .filter(({ ownerModuleId }) => activeModuleIds.has(ownerModuleId));
-    const activeRouteIdentityKeys = new Set(activeRoutes.map((route) => buildPhiCmsPresetIdentityKey(route.ownerModuleId, route.presetKey)));
+    const activeRoutes = [...routeTable.byPageId.values()];
     /*
      * Whether this reader is shown the entry, which is a different question from whether the address
      * answers. An entry says this for itself; it is never read off the route it points at, because the
@@ -893,9 +948,13 @@ export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeMod
         return canPhiViewerAccess(viewer, node.item.accessPolicy);
     };
     return (definition.navigationSurfaces ?? []).map((surface) => {
+        /*
+         * Every root is registered, the hidden ones too. Visibility is this reader's question and is asked
+         * where the tree is materialized; registering only what this reader sees made a root hidden from
+         * them an "unavailable" parent, so an injection under it refused the surface for that reader alone.
+         */
         const roots = surface.items
-            .map((item) => buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, surface.navKey, definition.baseModuleId, item, null))
-            .filter(isNavigationNodeVisible);
+            .map((item) => buildResolvedNavigationNode(catalog, routeTable, surface.navKey, definition.baseModuleId, item, null));
         const injectedRoots = [];
         const injectedByParent = new Map();
         const nodesByKey = new Map();
@@ -933,7 +992,7 @@ export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeMod
                 // Compiled against the surface already, so a named anchor is one the surface declares.
                 const placement = descriptor.anchor ? surface.anchors[descriptor.anchor] : null;
                 const parentItemKey = placement ? placement.parentItemKey : descriptor.parentItemKey;
-                const node = buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, surface.navKey, contributorId, descriptor.item, { descriptor, route, sortKey, position: placement?.position ?? null });
+                const node = buildResolvedNavigationNode(catalog, routeTable, surface.navKey, contributorId, descriptor.item, { descriptor, route, sortKey, position: placement?.position ?? null });
                 registerNode(node);
                 if (parentItemKey === null) {
                     injectedRoots.push(node);
@@ -1033,7 +1092,8 @@ export function resolvePhiCmsNavigationOverlay(surface, overlay) {
             continue;
         }
         if (override.label !== undefined) {
-            item.label = { ...item.label, defaultMessage: override.label };
+            // The operator's text now, in the Site's language: nothing of the Module's label carries over.
+            item.label = { defaultMessage: override.label };
         }
         if (override.icon !== undefined) {
             if (override.icon === null) {
@@ -1134,7 +1194,7 @@ export function resolvePhiCmsNavigationOverlay(surface, overlay) {
     return {
         surface: {
             ...surface,
-            ...(overlay.label ? { label: { ...surface.label, defaultMessage: overlay.label } } : {}),
+            ...(overlay.label ? { label: { defaultMessage: overlay.label } } : {}),
             items: visibleRoots,
         },
         diagnostics,
@@ -1180,20 +1240,6 @@ export function resolvePhiCmsAreaShellPresetBinding(catalog, area) {
 export function resolvePhiCmsRoutePresetByIdentity(catalog, ownerModuleId, presetKey) {
     return catalog.routeByIdentity.get(buildPhiCmsPresetIdentityKey(ownerModuleId, presetKey)) ?? null;
 }
-/**
- * The route a Module Page reference names, read off the whole catalogue.
- *
- * A reference carries the derived Page id and not the pair it was derived from, so this is the only way
- * in from a stored link: the hash cannot be undone, and the catalogue is the other side of it.
- *
- * The Area's active route table answers the same question for what that Area actually serves, and where
- * a caller has one it is the better question -- it has already dropped the Modules that are switched off
- * and the root applicants that lost. This one is for a caller holding only the catalogue, and it leaves
- * those checks to them.
- */
-export function resolvePhiCmsRouteDescriptorByPageId(catalog, pageId) {
-    return catalog.routeByPageId.get(pageId) ?? null;
-}
 export function resolvePhiCmsThemePresetBinding(catalog, themeKey, activeModuleIds) {
     const binding = catalog.themeByKey.get(themeKey.trim()) ?? null;
     return binding && activeModuleIds.has(binding.descriptor.ownerModuleId) ? binding : null;
@@ -1373,6 +1419,14 @@ export function assertPhiCmsPresetTreeContract(tree, expectedPage) {
             if (mismatch) {
                 throw new Error(`Preset Overlay "${overlay.id}" actions Footer does not match the canonical Layout preset at "${mismatch[0]}".`);
             }
+            if (overlay.overlayType === "modal") {
+                assertPhiCmsDialogCommands(overlay.id, footerLayout.id, tree.contentWidgets);
+            }
+        }
+    }
+    for (const overlay of tree.overlays) {
+        if (overlay.overlayType === "modal") {
+            assertPhiCmsDialogBody(overlay.id, layoutsById.get(overlay.bodyLayoutNodeId));
         }
     }
     for (const rootLayoutNodeId of [
@@ -1416,6 +1470,7 @@ export async function composePhiCmsActiveAreaOverlayPresets({ tree, catalog, act
     const overlays = [...tree.overlays];
     const layoutNodes = [...tree.layoutNodes];
     const contentWidgets = [...tree.contentWidgets];
+    let controllerSettings = tree.controllerSettings ?? [];
     for (const descriptor of descriptors) {
         const contribution = await descriptor.loadTree({
             page,
@@ -1436,8 +1491,15 @@ export async function composePhiCmsActiveAreaOverlayPresets({ tree, catalog, act
         overlays.push(...contribution.overlays);
         layoutNodes.push(...contribution.layoutNodes);
         contentWidgets.push(...contribution.contentWidgets);
+        // What the Overlay's Controllers are told comes with it, as its nodes do: a saved Area holds neither.
+        controllerSettings = concatPhiCmsTreeControllerSettings(controllerSettings, (contribution.controllerSettings ?? []).map((setting) => {
+            if (setting.mountScope !== "area") {
+                throw new Error(`${descriptor.ownerModuleId}/${descriptor.presetKey}: Area Overlay Controller settings are Area-scoped.`);
+            }
+            return setting;
+        }), "Area Overlay composition");
     }
-    return { ...tree, overlays, layoutNodes, contentWidgets };
+    return { ...tree, overlays, layoutNodes, contentWidgets, controllerSettings };
 }
 function resolveTargetRuntime(runtime, area) {
     return runtime.area === area ? runtime : { ...runtime, area };
@@ -1495,3 +1557,32 @@ export async function instantiatePhiCmsRoutePreset({ binding, catalog, activeMod
     assertPhiCmsPresetTreeContract(tree, page);
     return tree;
 }
+/*
+ * A dialog's body and actions are one answer for every dialog (`helpers/cms-dialog.ts`), checked here as
+ * the footer Layout is: a Preset that builds its dialog node by node must arrive at the same look as one
+ * that calls `dialog`. A vertical Flex carries the whole body config; a Layout of another kind -- a Stack
+ * of tabs -- carries the ground and the inset, which are what make it the dialog's body.
+ */
+function assertPhiCmsDialogBody(overlayId, body) {
+    // The bleed body is the other answer, for content that runs to the edge; it is matched whole.
+    const bleed = PHI_DIALOG_BLEED_BODY_CONFIG.padding === body.config.padding;
+    const required = bleed
+        ? PHI_DIALOG_BLEED_BODY_CONFIG
+        : body.widgetType === PhiCmsLayoutType.FlexVertical
+            ? PHI_DIALOG_BODY_CONFIG
+            : { surface: PHI_DIALOG_BODY_CONFIG.surface, padding: PHI_DIALOG_BODY_CONFIG.padding };
+    const mismatch = Object.entries(required).find(([key, value]) => JSON.stringify(body.config[key]) !== JSON.stringify(value));
+    if (mismatch) {
+        throw new Error(`Preset Overlay "${overlayId}" Body "${body.id}" does not match the dialog body (${bleed ? "PHI_DIALOG_BLEED_BODY_CONFIG" : "PHI_DIALOG_BODY_CONFIG"}) at "${mismatch[0]}".`);
+    }
+}
+function assertPhiCmsDialogCommands(overlayId, footerLayoutId, widgets) {
+    for (const widget of widgets) {
+        if (widget.parentLayoutNodeId !== footerLayoutId || widget.widgetType !== PhiCmsWidgetType.CommandToolbar)
+            continue;
+        const mismatch = Object.entries(PHI_DIALOG_COMMANDS_CONFIG).find(([key, value]) => widget.config[key] !== value);
+        if (mismatch) {
+            throw new Error(`Preset Overlay "${overlayId}" actions "${widget.id}" do not match the dialog actions (PHI_DIALOG_COMMANDS_CONFIG) at "${mismatch[0]}".`);
+        }
+    }
+}

package/plugins/runtime-modules/editor/client-data-providers.d.ts

@@ -0,0 +1,5 @@
+export declare const PHI_EDITOR_RUNTIME_DATA_PROVIDER_CLIENT_DEFINITIONS: readonly [{
+    readonly key: `${string}/${string}`;
+    readonly ownerModuleId: "@phis/ui/modules/editor";
+    readonly loadLive: () => Promise<typeof import("./services/releases-table").PhiEditorReleasesTableProviderClient>;
+}];

package/plugins/runtime-modules/editor/client-data-providers.js

@@ -0,0 +1,9 @@
+"use client";
+import { PHI_EDITOR_RELEASES_DATA_PROVIDER_KEY, PHI_EDITOR_RUNTIME_MODULE_ID } from "./ids";
+export const PHI_EDITOR_RUNTIME_DATA_PROVIDER_CLIENT_DEFINITIONS = [
+    {
+        key: PHI_EDITOR_RELEASES_DATA_PROVIDER_KEY,
+        ownerModuleId: PHI_EDITOR_RUNTIME_MODULE_ID,
+        loadLive: async () => (await import("./services/releases-table")).PhiEditorReleasesTableProviderClient,
+    },
+];

package/plugins/runtime-modules/editor/data-providers.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The Publisher's queue: submitted Widget content, submitted entries, and the Working Drafts of Pages and
+ * Areas (phis-server CONTENT.md, Submission).
+ *
+ * `live` and `authoringMode: "none"`, like every editorial record: the Builder has no business reading a
+ * Site's queue while somebody composes a Page. The rows come from `GET /api/site/editor/releases`, behind
+ * the guard of everybody who reads drafts; acting on them is the Publisher's, and Core refuses it to
+ * anybody else whatever a Table offers.
+ */
+export declare const PHI_EDITOR_RUNTIME_DATA_PROVIDER_DESCRIPTORS: {
+    key: `${string}/${string}`;
+    ownerModuleId: "@phis/ui/modules/editor";
+    kind: "table";
+    executionMode: "live";
+    authoringMode: "none";
+    title: string;
+    description: string;
+    resources: {
+        resourceKey: string;
+        title: string;
+        rowIdentityPath: string;
+        fields: ({
+            key: string;
+            title: string;
+            type: "string";
+            required: true;
+            options?: undefined;
+        } | {
+            key: string;
+            title: string;
+            type: "enum";
+            options: {
+                value: string;
+                label: string;
+            }[];
+            required?: undefined;
+        } | {
+            key: string;
+            title: string;
+            type: "string";
+            required?: undefined;
+            options?: undefined;
+        } | {
+            key: string;
+            title: string;
+            type: "datetime";
+            required?: undefined;
+            options?: undefined;
+        } | {
+            key: string;
+            title: string;
+            type: "boolean";
+            required?: undefined;
+            options?: undefined;
+        })[];
+        query: {
+            search: false;
+            sorting: "none";
+            pagination: "none";
+        };
+        recordRead: false;
+        actions: ({
+            key: string;
+            title: string;
+            scope: "row";
+            confirmation: "required";
+            disabledWhen: {
+                match: "any";
+                conditions: {
+                    source: "row";
+                    valuePath: string;
+                    operator: "falsy";
+                }[];
+            };
+        } | {
+            key: string;
+            title: string;
+            scope: "resource";
+            confirmation?: undefined;
+            disabledWhen?: undefined;
+        })[];
+    }[];
+}[];

package/plugins/runtime-modules/editor/data-providers.js

@@ -0,0 +1,75 @@
+import { PHI_EDITOR_RELEASES_DATA_PROVIDER_KEY, PHI_EDITOR_RELEASES_RESOURCE_KEY, PHI_EDITOR_RUNTIME_MODULE_ID, } from "./ids";
+/**
+ * The Publisher's queue: submitted Widget content, submitted entries, and the Working Drafts of Pages and
+ * Areas (phis-server CONTENT.md, Submission).
+ *
+ * `live` and `authoringMode: "none"`, like every editorial record: the Builder has no business reading a
+ * Site's queue while somebody composes a Page. The rows come from `GET /api/site/editor/releases`, behind
+ * the guard of everybody who reads drafts; acting on them is the Publisher's, and Core refuses it to
+ * anybody else whatever a Table offers.
+ */
+export const PHI_EDITOR_RUNTIME_DATA_PROVIDER_DESCRIPTORS = [
+    {
+        key: PHI_EDITOR_RELEASES_DATA_PROVIDER_KEY,
+        ownerModuleId: PHI_EDITOR_RUNTIME_MODULE_ID,
+        kind: "table",
+        executionMode: "live",
+        authoringMode: "none",
+        title: "Releases",
+        description: "What waits for a Publisher: submitted content and entries, and Page and Area drafts.",
+        resources: [
+            {
+                resourceKey: PHI_EDITOR_RELEASES_RESOURCE_KEY,
+                title: "Releases",
+                rowIdentityPath: "id",
+                fields: [
+                    { key: "id", title: "ID", type: "string", required: true },
+                    {
+                        key: "kind",
+                        title: "Kind",
+                        type: "enum",
+                        options: [
+                            { value: "content", label: "Content" },
+                            { value: "entry", label: "Entry" },
+                            { value: "page", label: "Page" },
+                            { value: "area", label: "Area" },
+                        ],
+                    },
+                    { key: "what", title: "What", type: "string" },
+                    { key: "where", title: "Where", type: "string" },
+                    { key: "by", title: "By", type: "string" },
+                    { key: "at", title: "When", type: "datetime" },
+                    { key: "publishable", title: "Can be published here", type: "boolean" },
+                    { key: "rejectable", title: "Can be sent back", type: "boolean" },
+                ],
+                query: {
+                    search: false,
+                    sorting: "none",
+                    pagination: "none",
+                },
+                recordRead: false,
+                actions: [
+                    {
+                        key: "publish",
+                        title: "Publish",
+                        scope: "row",
+                        confirmation: "required",
+                        disabledWhen: { match: "any", conditions: [
+                                { source: "row", valuePath: "publishable", operator: "falsy" },
+                            ] },
+                    },
+                    {
+                        key: "reject",
+                        title: "Send back",
+                        scope: "row",
+                        confirmation: "required",
+                        disabledWhen: { match: "any", conditions: [
+                                { source: "row", valuePath: "rejectable", operator: "falsy" },
+                            ] },
+                    },
+                    { key: "refresh", title: "Refresh", scope: "resource" },
+                ],
+            },
+        ],
+    },
+];