@phis/ui 0.4.2 → 0.4.4

package/plugins/runtime-modules/builder/services/runtime-modules-table.js

@@ -293,10 +293,10 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
      * they run -- which is also what a mutation has to do, since the answer it writes back is to the
      * selection as it stands then, not as it stood when the provider registered.
      */
-    const runtimeModuleDefinitions = usePhiDeveloperBuilderStateValue("public", (state) => state.runtimeModuleDefinitions);
-    const runtimeModuleIdsByArea = usePhiDeveloperBuilderStateValue("public", (state) => state.runtimeModuleIdsByArea);
-    const unresolvedModuleIdsByArea = usePhiDeveloperBuilderStateValue("public", (state) => state.unresolvedModuleIdsByArea);
-    const serverUnavailableModules = usePhiDeveloperBuilderStateValue("public", (state) => state.serverUnavailableModules);
+    const runtimeModuleDefinitions = usePhiDeveloperBuilderStateValue((state) => state.runtimeModuleDefinitions);
+    const runtimeModuleIdsByArea = usePhiDeveloperBuilderStateValue((state) => state.runtimeModuleIdsByArea);
+    const unresolvedModuleIdsByArea = usePhiDeveloperBuilderStateValue((state) => state.unresolvedModuleIdsByArea);
+    const serverUnavailableModules = usePhiDeveloperBuilderStateValue((state) => state.serverUnavailableModules);
     const registration = useMemo(() => {
         const descriptor = PHI_BUILDER_RUNTIME_DATA_PROVIDER_DESCRIPTORS.find((candidate) => candidate.key === PHI_BUILDER_RUNTIME_DATA_PROVIDER_KEYS.runtimeModulesTable);
         const resources = descriptor?.kind === "table" ? descriptor.resources : [];
@@ -309,7 +309,7 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
             throw new Error("Runtime Modules Table provider descriptor has no resource.");
         }
         const query = async (request) => {
-            const builderState = getPhiDeveloperBuilderStateSnapshot("public");
+            const builderState = getPhiDeveloperBuilderStateSnapshot();
             if (request.resourceKey === DETAIL_RESOURCE_KEY) {
                 const moduleId = typeof request.params?.moduleId === "string" ? request.params.moduleId : "";
                 const areaLabels = readAreaLabels(request.params);
@@ -360,7 +360,7 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
             }, { ...request, query: filteredQuery });
         };
         const mutate = async (request) => {
-            const builderState = getPhiDeveloperBuilderStateSnapshot("public");
+            const builderState = getPhiDeveloperBuilderStateSnapshot();
             if (request.resourceKey === MODULE_USAGE_RESOURCE_KEY) {
                 return { status: "rejected", invalidation: "none", errorCode: "unsupported-mutation" };
             }
@@ -369,7 +369,7 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
                     return { status: "rejected", invalidation: "none", errorCode: "unsupported-mutation" };
                 }
                 const path = typeof request.proposedValue === "string" ? request.proposedValue.trim() : "";
-                answerPhiBuilderPublicRouteCollision("public", String(request.rowIdentity), path);
+                answerPhiBuilderPublicRouteCollision(String(request.rowIdentity), path);
                 return { status: "accepted", invalidation: "none", rowPatch: { path } };
             }
             if (request.resourceKey !== RESOURCE_KEY) {
@@ -409,7 +409,7 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
                 if (answers.length === 0) {
                     return false;
                 }
-                openPhiBuilderPublicRouteCollisionRequest("public", {
+                openPhiBuilderPublicRouteCollisionRequest({
                     moduleId: definition.moduleId,
                     moduleTitle: definition.title,
                     areas: cmsAreas.filter((areaKey) => isPhiBuilderAreaKey(areaKey)),
@@ -456,7 +456,7 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
                 if (usage.length === 0) {
                     return false;
                 }
-                openPhiBuilderModuleDeactivationRequest("public", {
+                openPhiBuilderModuleDeactivationRequest({
                     moduleId: definition.moduleId,
                     moduleTitle: definition.title,
                     areas,
@@ -476,7 +476,7 @@ export function PhiBuilderRuntimeModulesTableProviderClient({ children }) {
                             : currentModuleIds.filter((candidateId) => candidateId !== definition.moduleId),
                     };
                 });
-                applyPhiBuilderRuntimeModuleSelectionChanges(changes, "public");
+                applyPhiBuilderRuntimeModuleSelectionChanges(changes);
             };
             // The row's switch: the Module as a whole, i.e. every eligible Area in one gesture.
             if (request.fieldKey === "active") {

package/plugins/runtime-modules/builder/services/signal-routes-table.js

@@ -50,8 +50,8 @@ export function PhiBuilderSignalRoutesTableProviderClient({ children }) {
             }
             const sessionKey = readSessionKey(request);
             const currentRoutes = sessionKey
-                ? routeTableSessions.current.get(sessionKey) ?? getPhiDeveloperSelectedSignalRoutes("public")
-                : getPhiDeveloperSelectedSignalRoutes("public");
+                ? routeTableSessions.current.get(sessionKey) ?? getPhiDeveloperSelectedSignalRoutes()
+                : getPhiDeveloperSelectedSignalRoutes();
             if (sessionKey && !routeTableSessions.current.has(sessionKey)) {
                 routeTableSessions.current.set(sessionKey, currentRoutes ?? {});
             }
@@ -72,7 +72,7 @@ export function PhiBuilderSignalRoutesTableProviderClient({ children }) {
                 throw new Error("Invalid Signal Routes Table mutation.");
             }
             const current = routeTableSessions.current.get(sessionKey) ??
-                getPhiDeveloperSelectedSignalRoutes("public") ?? {};
+                getPhiDeveloperSelectedSignalRoutes() ?? {};
             if (request.actionKey === "cancel") {
                 routeTableSessions.current.delete(sessionKey);
             }

package/plugins/runtime-modules/builder/signal-route-selection.d.ts

@@ -1,3 +1,2 @@
 import { type PhiSignalRouteSet } from "../../../types/signals";
-import type { PhiDeveloperBuilderArea } from "./developer-workspace-types";
-export declare function getPhiDeveloperSelectedSignalRoutes(defaultArea: PhiDeveloperBuilderArea): PhiSignalRouteSet | null;
+export declare function getPhiDeveloperSelectedSignalRoutes(): PhiSignalRouteSet | null;

package/plugins/runtime-modules/builder/signal-route-selection.js

@@ -25,7 +25,7 @@ function resolveSelectedSignalRouteConfig(state, drafts = getPhiDeveloperRegionD
     }
     return null;
 }
-export function getPhiDeveloperSelectedSignalRoutes(defaultArea) {
-    const state = getPhiDeveloperBuilderStateSnapshot(defaultArea);
+export function getPhiDeveloperSelectedSignalRoutes() {
+    const state = getPhiDeveloperBuilderStateSnapshot();
     return readPhiSignalRouteSet(resolveSelectedSignalRouteConfig(state)?.signalRoutes);
 }

package/plugins/runtime-modules/builder/signal-wiring-options.js

@@ -1,4 +1,5 @@
 "use client";
+import { PHI_WORKSPACE_CATALOG_SCOPE } from "../../../components/workspace/catalog-store";
 import { PHI_BUILDER_RUNTIME_DATA_PROVIDER_KEYS } from "./ids";
 import { createPhiControlOptionsProviderClient, } from "../../../components/controls/phi-options-provider";
 import { readPhiBuilderBoundCollectionResource } from "./selected-collection-source";
@@ -193,8 +194,8 @@ function resolveReceiverCapabilityOptions(context) {
     };
 }
 const wiringProviderStore = {
-    subscribe: (listener) => builderWorkspaceStore.subscribe("public", listener),
-    getSnapshot: () => getPhiDeveloperBuilderStateSnapshot("public"),
+    subscribe: (listener) => builderWorkspaceStore.subscribe(PHI_WORKSPACE_CATALOG_SCOPE, listener),
+    getSnapshot: () => getPhiDeveloperBuilderStateSnapshot(),
 };
 export const PhiBuilderSignalSendersOptionsProviderClient = createPhiControlOptionsProviderClient({
     key: PHI_BUILDER_RUNTIME_DATA_PROVIDER_KEYS.signalSenders,

package/plugins/runtime-modules/builder/structure-dnd.js

@@ -2,9 +2,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { DndContext, DragOverlay, PointerSensor, pointerWithin, useDraggable, useDroppable, useSensor, useSensors, } from "@dnd-kit/core";
 import { createContext, useContext, useEffect, useMemo, useRef, useState, } from "react";
-import { PHI_SIGNAL_VALUE_SCHEMAS } from "../../../types/signals";
-import { usePhiSignalDispatcher } from "../../../components/runtime/runtime-signal-bus";
-import { createPhiBuilderControllerAddress } from "./controller/address";
 const PhiStructureDndContext = createContext({
     active: null,
     acceptedTargetId: null,
@@ -61,47 +58,18 @@ function PhiStructureDragSnapshot({ source, }) {
         } }));
 }
 export function PhiStructureDndProvider({ children, }) {
-    const emitSignal = usePhiSignalDispatcher();
     const sensors = useSensors(useSensor(PointerSensor, {
         activationConstraint: { distance: 4 },
     }));
     const [active, setActive] = useState(null);
     const [acceptedTargetId, setAcceptedTargetId] = useState(null);
-    const lastOverTargetIdRef = useRef(null);
     const previewElement = active?.getPreviewElement() ?? null;
-    const emitDragSignal = (source, input) => {
-        const controller = createPhiBuilderControllerAddress();
-        emitSignal({
-            scope: source.pageScoped ? "page" : "area",
-            channel: input.channel,
-            action: input.action,
-            value: {
-                area: source.area,
-                pageKey: source.pageKey,
-                sourceRegionKey: source.regionKey,
-                sourceNodeId: source.nodeId,
-                sourceNodeKind: source.nodeKind,
-                targetRegionKey: input.target?.regionKey ?? null,
-                targetKey: input.target?.id ?? null,
-                targetNodeId: input.target?.targetNodeId ?? null,
-                dropMode: input.target?.dropMode ?? null,
-                accepted: input.accepted ?? null,
-            },
-            valueType: "json",
-            valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.dragDrop,
-            sender: controller,
-            receiver: controller,
-            timestamp: Date.now(),
-        });
-    };
-    const finish = (source) => {
-        if (source) {
-            emitDragSignal(source, {
-                channel: "drag",
-                action: "stop",
-            });
-        }
-        lastOverTargetIdRef.current = null;
+    /*
+     * The drag stays inside this context: the drop moves the node through its target, and nothing is
+     * signalled. The Builder Controller used to send `drag/*` and `drop/drop` here, addressed to itself,
+     * which answers nothing under its own address -- four declared outputs that never reached anybody.
+     */
+    const finish = () => {
         setAcceptedTargetId(null);
         setActive(null);
     };
@@ -111,10 +79,6 @@ export function PhiStructureDndProvider({ children, }) {
             return;
         }
         setActive(source);
-        emitDragSignal(source, {
-            channel: "drag",
-            action: "start",
-        });
     };
     const handleDragOver = (event) => {
         const source = readStructureDragData(event);
@@ -122,17 +86,6 @@ export function PhiStructureDndProvider({ children, }) {
         const accepted = !!source && !!target && target.accepts(source);
         const nextTargetId = accepted ? target.id : null;
         setAcceptedTargetId((current) => current === nextTargetId ? current : nextTargetId);
-        if (source &&
-            target &&
-            lastOverTargetIdRef.current !== `${target.id}:${accepted}`) {
-            lastOverTargetIdRef.current = `${target.id}:${accepted}`;
-            emitDragSignal(source, {
-                channel: "drag",
-                action: "change",
-                target,
-                accepted,
-            });
-        }
     };
     const handleDragEnd = (event) => {
         const source = readStructureDragData(event);
@@ -140,14 +93,8 @@ export function PhiStructureDndProvider({ children, }) {
         const accepted = !!source && !!target && target.accepts(source);
         if (source && target && accepted) {
             target.drop(source);
-            emitDragSignal(source, {
-                channel: "drop",
-                action: "drop",
-                target,
-                accepted: true,
-            });
         }
-        finish(source);
+        finish();
     };
     const contextValue = useMemo(() => ({ active, acceptedTargetId }), [acceptedTargetId, active]);
     useEffect(() => {
@@ -156,7 +103,7 @@ export function PhiStructureDndProvider({ children, }) {
             document.documentElement.removeAttribute("data-phi-structure-drop-accepted");
         };
     }, [acceptedTargetId]);
-    return (_jsx(DndContext, { sensors: sensors, collisionDetection: pointerWithin, onDragStart: handleDragStart, onDragOver: handleDragOver, onDragEnd: handleDragEnd, onDragCancel: () => finish(active), children: _jsxs(PhiStructureDndContext.Provider, { value: contextValue, children: [children, _jsx(DragOverlay, { dropAnimation: null, children: active ? _jsx(PhiStructureDragSnapshot, { source: previewElement }) : null })] }) }));
+    return (_jsx(DndContext, { sensors: sensors, collisionDetection: pointerWithin, onDragStart: handleDragStart, onDragOver: handleDragOver, onDragEnd: handleDragEnd, onDragCancel: finish, children: _jsxs(PhiStructureDndContext.Provider, { value: contextValue, children: [children, _jsx(DragOverlay, { dropAnimation: null, children: active ? _jsx(PhiStructureDragSnapshot, { source: previewElement }) : null })] }) }));
 }
 export function usePhiStructureDraggable(id, data) {
     return useDraggable({

package/plugins/runtime-modules/builder/trees/phi-default-builder-area-preset-tree.js

@@ -273,17 +273,20 @@ function remapBuilderPresetTreeInstanceIds(tree, ownerModuleId, presetKey) {
         from: createPhiSignalAddress("cms", from),
         to: createPhiSignalAddress("cms", to),
     }));
-    const remapInstanceId = (value) => value == null ? null : (instanceIdRemaps.get(value) ?? value);
+    // One id stays one id: a node whose id is not remapped keeps its own, so nothing here can come back
+    // empty. The nullable form is for the links a tree may leave unset, and only for those.
+    const remapInstanceId = (value) => instanceIdRemaps.get(value) ?? value;
+    const remapOptionalInstanceId = (value) => value == null ? null : remapInstanceId(value);
     return {
         ...tree,
         page: {
             ...tree.page,
-            heroRootLayoutNodeId: remapInstanceId(tree.page.heroRootLayoutNodeId),
-            headerBottomRootLayoutNodeId: remapInstanceId(tree.page.headerBottomRootLayoutNodeId),
-            siderRightRootLayoutNodeId: remapInstanceId(tree.page.siderRightRootLayoutNodeId),
-            footerTopRootLayoutNodeId: remapInstanceId(tree.page.footerTopRootLayoutNodeId),
-            drawerRightRootLayoutNodeId: remapInstanceId(tree.page.drawerRightRootLayoutNodeId),
-            contentRootLayoutNodeId: remapInstanceId(tree.page.contentRootLayoutNodeId),
+            heroRootLayoutNodeId: remapOptionalInstanceId(tree.page.heroRootLayoutNodeId),
+            headerBottomRootLayoutNodeId: remapOptionalInstanceId(tree.page.headerBottomRootLayoutNodeId),
+            siderRightRootLayoutNodeId: remapOptionalInstanceId(tree.page.siderRightRootLayoutNodeId),
+            footerTopRootLayoutNodeId: remapOptionalInstanceId(tree.page.footerTopRootLayoutNodeId),
+            drawerRightRootLayoutNodeId: remapOptionalInstanceId(tree.page.drawerRightRootLayoutNodeId),
+            contentRootLayoutNodeId: remapOptionalInstanceId(tree.page.contentRootLayoutNodeId),
         },
         regions: tree.regions.map((region) => ({
             ...region,
@@ -292,7 +295,7 @@ function remapBuilderPresetTreeInstanceIds(tree, ownerModuleId, presetKey) {
         overlays: tree.overlays.map((overlay) => ({
             ...overlay,
             id: remapInstanceId(overlay.id),
-            headerLayoutNodeId: remapInstanceId(overlay.headerLayoutNodeId),
+            headerLayoutNodeId: remapOptionalInstanceId(overlay.headerLayoutNodeId),
             bodyLayoutNodeId: remapInstanceId(overlay.bodyLayoutNodeId),
             ...(overlay.footerPresentation === "none"
                 ? { footerPresentation: "none", footerLayoutNodeId: null }
@@ -305,7 +308,7 @@ function remapBuilderPresetTreeInstanceIds(tree, ownerModuleId, presetKey) {
         layoutNodes: tree.layoutNodes.map((node) => ({
             ...node,
             id: remapInstanceId(node.id),
-            parentLayoutNodeId: remapInstanceId(node.parentLayoutNodeId),
+            parentLayoutNodeId: remapOptionalInstanceId(node.parentLayoutNodeId),
             config: remapPhiSignalRoutesInConfig(node.config, signalRemaps),
         })),
         // The Controller's routes name the same receivers the nodes' routes do, so they move with them.
@@ -1487,14 +1490,18 @@ async function buildPhiDefaultBuilderPagePresetTemplateTree({ page, runtime, pre
                                         key: "createPage",
                                         emits: [{ capabilityId: "command", value: "createPage" }],
                                         label: labels.pages.newPage,
+                                        tooltip: labels.pages.newPage,
                                         icon: "plus",
+                                        display: "icon",
                                         variant: "primary",
                                     },
                                     {
                                         key: "editPageMeta",
                                         emits: [{ capabilityId: "command", value: "editPageMeta" }],
                                         label: labels.pages.pageMeta,
+                                        tooltip: labels.pages.pageMeta,
                                         icon: "edit",
+                                        display: "icon",
                                     },
                                     {
                                         key: "deletePage",
@@ -1880,7 +1887,7 @@ async function buildPhiDefaultBuilderPagePresetTemplateTree({ page, runtime, pre
                                 },
                             }),
                         ]
-                        : isNavigationPage
+                        : navigationLabels
                             ? [
                                 nodes.widget({
                                     typeKey: "command-toolbar",

package/plugins/runtime-modules/builder/widgets/structure-region/built-in.js

@@ -40,6 +40,7 @@ import { PhiTypographyControl } from "../../../../../components/controls/phi-typ
 import { PhiIcon } from "../../../../../components/shell/phi-icon";
 import { PhiSurfaceTone } from "../../../../../components/surface/phi-surface-tone";
 import { resolvePhiSurfaceToneClassName } from "../../../../../types/surface";
+import { PHI_SURFACE_TONE_GROUND, phiSurfaceTakesToneGround } from "../../../../../helpers/surface-style";
 /** The Region's root Layout placed into another tree, at the slot it is moved to. */
 function buildStructureRootLayoutNode(draft, parentLayoutNodeId, slotIndex) {
     if (!draft.rootNode) {
@@ -296,13 +297,13 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
     const activeModules = usePhiRuntimeModuleState();
     const authoringCanvas = usePhiBuilderAuthoringCanvas();
     const builderState = {
-        area: usePhiDeveloperBuilderStateValue("public", (state) => state.area),
-        pageKey: usePhiDeveloperBuilderStateValue("public", (state) => state.pageKey),
-        builderMode: usePhiDeveloperBuilderStateValue("public", (state) => state.builderMode),
-        debugScaffold: usePhiDeveloperBuilderStateValue("public", (state) => state.debugScaffold),
-        pickerWidgetCategoryFilters: usePhiDeveloperBuilderStateValue("public", (state) => state.pickerWidgetCategoryFilters),
-        selectedLayoutAnchor: usePhiDeveloperBuilderStateValue("public", (state) => state.selectedRootRegionKey === config.regionKey ? state.selectedLayoutAnchor : null),
-        regionSelected: usePhiDeveloperBuilderStateValue("public", (state) => state.nodeKind === "region" && state.selectedRegionKey === config.regionKey),
+        area: usePhiDeveloperBuilderStateValue((state) => state.area),
+        pageKey: usePhiDeveloperBuilderStateValue((state) => state.pageKey),
+        builderMode: usePhiDeveloperBuilderStateValue((state) => state.builderMode),
+        debugScaffold: usePhiDeveloperBuilderStateValue((state) => state.debugScaffold),
+        pickerWidgetCategoryFilters: usePhiDeveloperBuilderStateValue((state) => state.pickerWidgetCategoryFilters),
+        selectedLayoutAnchor: usePhiDeveloperBuilderStateValue((state) => state.selectedRootRegionKey === config.regionKey ? state.selectedLayoutAnchor : null),
+        regionSelected: usePhiDeveloperBuilderStateValue((state) => state.nodeKind === "region" && state.selectedRegionKey === config.regionKey),
     };
     const builderModuleMetas = usePhiBuilderModuleMetas(builderState.area);
     const layoutMetasByType = useMemo(() => buildPhiBuilderContainerMetaMap(builderModuleMetas.plugins), [builderModuleMetas.plugins]);
@@ -353,16 +354,26 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
     const shouldStretchAvailableHeight = shouldFillAvailableHeight || shouldStretchContentRegion;
     const hasExplicitSidebarWidth = isFullHeightRegion && draftGeometry.explicitInline;
     const regionToneClassName = resolvePhiSurfaceToneClassName(effectiveDraft?.surface?.tone);
-    const slotBackgroundStyle = effectiveDraft?.surface?.background
-        ? resolvePhiBackgroundWidgetStyle(effectiveDraft.surface.background)
-        : {};
     /*
      * Whether the author gave this Region a ground. The Builder writes a Background config onto every
      * Region draft it persists, so only a config that paints something counts. An unauthored Region is
      * transparent in the live Shell, and the Canvas keeps that legible: its slot paints a half-transparent
      * container tint, so the Theme Root Background stays visible through it.
      */
-    const hasAuthoredGround = phiBackgroundWidgetConfigPaintsGround(effectiveDraft?.surface?.background ?? null);
+    const paintsAuthoredGround = phiBackgroundWidgetConfigPaintsGround(effectiveDraft?.surface?.background ?? null);
+    /*
+     * A toned Region takes its tone's ground where its Background paints none, by the rule the live Region
+     * shell follows (`phiSurfaceTakesToneGround`). The slot carries the tone's class, so the ground resolves
+     * in the tone's mode; it is a ground of the Region's own, so the Canvas tint does not cover it.
+     */
+    const toneGround = phiSurfaceTakesToneGround(effectiveDraft?.surface?.tone, paintsAuthoredGround);
+    const hasAuthoredGround = paintsAuthoredGround || toneGround;
+    const slotBackgroundStyle = {
+        ...(effectiveDraft?.surface?.background
+            ? resolvePhiBackgroundWidgetStyle(effectiveDraft.surface.background)
+            : {}),
+        ...(toneGround ? { backgroundColor: PHI_SURFACE_TONE_GROUND } : {}),
+    };
     const slotBorderStyle = effectiveDraft?.surface?.border ? resolvePhiBorderWidgetStyle(effectiveDraft.surface.border) : {};
     const regionConfig = (effectiveDraft?.regionConfig ?? null);
     const regionPaddingStyle = resolvePhiPaddingStyle(normalizePhiPaddingWidgetConfig(effectiveDraft?.regionConfig) ?? {});
@@ -424,9 +435,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
         if (!hasRootNode || isPreviewMode || !rootNodeKind) {
             return;
         }
-        selectPhiDeveloperBuilderNode("public", {
-            area: builderState.area,
-            pageKey: builderState.pageKey,
+        selectPhiDeveloperBuilderNode({
             regionKey: config.regionKey,
             nodeId: options?.nodeId ?? rootNodeId,
             nodeKey: options?.nodeKey ?? rootNodeTypeKey,
@@ -1026,7 +1035,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
     }, [builderMode, isPicking]);
     useEffect(() => {
         if (!Array.isArray(builderState.pickerWidgetCategoryFilters)) {
-            patchPhiDeveloperBuilderState("public", { pickerWidgetCategoryFilters: [] });
+            patchPhiDeveloperBuilderState({ pickerWidgetCategoryFilters: [] });
         }
     }, [builderState.pickerWidgetCategoryFilters]);
     useEffect(() => {
@@ -1074,9 +1083,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
         if (!config.allowSelect || isPreviewMode) {
             return;
         }
-        selectPhiDeveloperBuilderNode("public", {
-            area: builderState.area,
-            pageKey: builderState.pageKey,
+        selectPhiDeveloperBuilderNode({
             nodeKind: "region",
             nodeKey: `region:${config.regionKey}`,
             regionKey: config.regionKey,
@@ -1113,9 +1120,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
         setSlotPickerContext(nextSlotPickerContext);
         setPickSection(nextDefaultPickSection);
         setIsPicking(true);
-        selectPhiDeveloperBuilderNode("public", {
-            area: builderState.area,
-            pageKey: builderState.pageKey,
+        selectPhiDeveloperBuilderNode({
             regionKey: config.regionKey,
             nodeKey: `slot:${config.regionKey}`,
             nodeKind: "slot",
@@ -1150,7 +1155,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
                 if (!nextOpen && isActiveTarget)
                     closePicker();
             }, onSectionChange: setPickSection, onPackageFiltersChange: setPickPackageFilters, onWidgetCategoryFiltersChange: (filters) => {
-                patchPhiDeveloperBuilderState("public", { pickerWidgetCategoryFilters: filters });
+                patchPhiDeveloperBuilderState({ pickerWidgetCategoryFilters: filters });
             }, onChange: (item) => void insertPickedItem(item) }, key));
     }
     /*

package/plugins/runtime-modules/builder/workspace-catalog-actions.d.ts

@@ -0,0 +1,55 @@
+import { type PhiWorkspaceCatalogState } from "../../../components/workspace/catalog-store";
+import type { PhiBuilderPersistedPageCatalogEntry, PhiPresetPageNode } from "../../../helpers/cms-page-catalog";
+import type { PhiCmsResolvedNavigationSurface } from "../../../types/cms-module-descriptors";
+import type { PhiRuntimeModuleId } from "../../../types";
+import type { PhiDeveloperBuilderArea } from "./developer-workspace-types";
+/** The Area and Page being worked on. Leaves the catalog as it is when both are already open. */
+export declare function openPhiWorkspacePage(area: PhiDeveloperBuilderArea, pageKey: string): void;
+/** The Page being worked on, within the Area that is open. */
+export declare function setPhiWorkspacePageKey(pageKey: string): void;
+/** The Site's own Pages of one Area, as the server answered them; the Area's catalog counts as read. */
+export declare function storePhiWorkspacePersistedPages(area: PhiDeveloperBuilderArea, pages: PhiBuilderPersistedPageCatalogEntry[]): void;
+/** A Page created in the Builder and not saved yet. */
+export declare function addPhiWorkspaceCustomPage(area: PhiDeveloperBuilderArea, page: PhiPresetPageNode): void;
+/** A navigation created in the Builder, added to the surfaces of its Area. */
+export declare function addPhiWorkspaceNavigationSurface(area: PhiDeveloperBuilderArea, surface: PhiCmsResolvedNavigationSurface): void;
+/** The Pages and navigation surfaces the active Modules contribute, when the Module selection changed. */
+export declare function setPhiWorkspaceActiveCatalogs(catalogs: Pick<PhiWorkspaceCatalogState, "modulePresetPagesByArea" | "navigationSurfacesByArea">): void;
+/** The Module selection of the named Areas; the other Areas keep theirs. */
+export declare function setPhiWorkspaceModuleSelection(moduleIdsByArea: Partial<Record<PhiDeveloperBuilderArea, PhiRuntimeModuleId[]>>): void;
+/**
+ * The Public addresses one Module's Pages take, as the collision dialog answered them. The Module's
+ * other assignments, and every other Module's, stay.
+ */
+export declare function assignPhiWorkspacePublicRoutePaths(moduleId: PhiRuntimeModuleId, answers: ReadonlyMap<string, string>): void;
+/** Catalog fields an undo or redo puts back (`splitWorkspacePatch`). */
+export declare function restorePhiWorkspaceCatalog(fields: Partial<PhiWorkspaceCatalogState>): void;
+/** What the server rendered the Builder with, as its preload hands it in. */
+export type PhiWorkspaceCatalogPreload = Pick<PhiWorkspaceCatalogState, "areaPresetSourcesByArea" | "unresolvedModuleIdsByArea" | "serverUnavailableModules" | "publicRouteClaims" | "publicRoutePaths"> & {
+    runtimeModuleDefinitions: readonly PhiWorkspaceCatalogState["runtimeModuleDefinitions"][number][];
+    runtimeModuleIdsByArea: Readonly<Record<string, PhiRuntimeModuleId[]>>;
+    /** The Pages and surfaces of the active Modules, which is what the catalog holds. */
+    activeCatalogs: Pick<PhiWorkspaceCatalogState, "modulePresetPagesByArea" | "navigationSurfacesByArea">;
+    /**
+     * The server's answer, serialized, per field: a field is taken again only when this differs from what
+     * the catalog holds, so an unsaved edit -- a Module selection, a collision answer -- survives a
+     * re-render that brought nothing new.
+     */
+    keys: {
+        runtimeModuleDefinitions: string;
+        modulePresetPagesByArea: string;
+        areaPresetSourcesByArea: string;
+        navigationSurfacesByArea: string;
+        unresolvedModuleIdsByArea: string;
+        publicRouteClaims: string;
+        serverUnavailableModules: string;
+        publicRoutePaths: string;
+    };
+    normalizeArea: (area: string) => PhiDeveloperBuilderArea;
+};
+/**
+ * Feeds the server's preload into the catalog, and answers the Page it opened when none was open yet --
+ * the caller selects that Page in the Builder. Nothing else is written from inside the update, so the
+ * Builder's own store is never patched from within the catalog's.
+ */
+export declare function applyPhiWorkspaceCatalogPreload(preload: PhiWorkspaceCatalogPreload): string | null;

package/plugins/runtime-modules/builder/workspace-catalog-actions.js

@@ -0,0 +1,142 @@
+"use client";
+import { PHI_WORKSPACE_CATALOG_SCOPE, phiWorkspaceCatalogStore, } from "../../../components/workspace/catalog-store";
+import { resolvePhiBuilderActivePageKey } from "../../../helpers/cms-page-catalog";
+import { normalizePhiAreaPublicRoutePaths } from "../../../helpers/cms-area-config";
+/*
+ * Every write the Builder makes to the workspace catalog (`components/workspace/catalog-store.ts`).
+ *
+ * The catalog is the Foundation's -- revisions read it, and the Editor will feed it -- but on this side
+ * only the Builder feeds it, and it does so here and nowhere else. Each write is a named action, so
+ * "who changes which Area is open" has one answer; before, fourteen places in six files patched the
+ * store with whatever they held. `scripts/validate-builder-store-ownership.mjs` keeps it that way.
+ */
+function patchCatalog(update) {
+    phiWorkspaceCatalogStore.patch(PHI_WORKSPACE_CATALOG_SCOPE, update);
+}
+/** The Area and Page being worked on. Leaves the catalog as it is when both are already open. */
+export function openPhiWorkspacePage(area, pageKey) {
+    patchCatalog((current) => (current.area === area && current.pageKey === pageKey
+        ? current
+        : { ...current, area, pageKey }));
+}
+/** The Page being worked on, within the Area that is open. */
+export function setPhiWorkspacePageKey(pageKey) {
+    patchCatalog((current) => (current.pageKey === pageKey ? current : { ...current, pageKey }));
+}
+/** The Site's own Pages of one Area, as the server answered them; the Area's catalog counts as read. */
+export function storePhiWorkspacePersistedPages(area, pages) {
+    patchCatalog((current) => ({
+        ...current,
+        persistedPageCatalogByArea: { ...current.persistedPageCatalogByArea, [area]: pages },
+        pageCatalogHydratedByArea: { ...current.pageCatalogHydratedByArea, [area]: true },
+    }));
+}
+/** A Page created in the Builder and not saved yet. */
+export function addPhiWorkspaceCustomPage(area, page) {
+    patchCatalog((current) => ({
+        ...current,
+        customPages: { ...current.customPages, [area]: [...(current.customPages[area] ?? []), page] },
+    }));
+}
+/** A navigation created in the Builder, added to the surfaces of its Area. */
+export function addPhiWorkspaceNavigationSurface(area, surface) {
+    patchCatalog((current) => ({
+        ...current,
+        navigationSurfacesByArea: {
+            ...current.navigationSurfacesByArea,
+            [area]: [...(current.navigationSurfacesByArea[area] ?? []), surface],
+        },
+    }));
+}
+/** The Pages and navigation surfaces the active Modules contribute, when the Module selection changed. */
+export function setPhiWorkspaceActiveCatalogs(catalogs) {
+    patchCatalog((current) => (JSON.stringify(current.modulePresetPagesByArea) === JSON.stringify(catalogs.modulePresetPagesByArea) &&
+        JSON.stringify(current.navigationSurfacesByArea) === JSON.stringify(catalogs.navigationSurfacesByArea)
+        ? current
+        : { ...current, ...catalogs }));
+}
+/** The Module selection of the named Areas; the other Areas keep theirs. */
+export function setPhiWorkspaceModuleSelection(moduleIdsByArea) {
+    patchCatalog((current) => ({
+        ...current,
+        runtimeModuleIdsByArea: { ...(current.runtimeModuleIdsByArea ?? {}), ...moduleIdsByArea },
+    }));
+}
+/**
+ * The Public addresses one Module's Pages take, as the collision dialog answered them. The Module's
+ * other assignments, and every other Module's, stay.
+ */
+export function assignPhiWorkspacePublicRoutePaths(moduleId, answers) {
+    patchCatalog((current) => {
+        const kept = (current.publicRoutePaths ?? []).filter((assignment) => assignment.ownerModuleId !== moduleId || !answers.has(assignment.presetKey));
+        return {
+            ...current,
+            publicRoutePaths: normalizePhiAreaPublicRoutePaths([
+                ...kept,
+                ...[...answers.entries()].map(([presetKey, path]) => ({ ownerModuleId: moduleId, presetKey, path })),
+            ]),
+        };
+    });
+}
+/** Catalog fields an undo or redo puts back (`splitWorkspacePatch`). */
+export function restorePhiWorkspaceCatalog(fields) {
+    if (Object.keys(fields).length === 0)
+        return;
+    patchCatalog((current) => ({ ...current, ...fields }));
+}
+/**
+ * Feeds the server's preload into the catalog, and answers the Page it opened when none was open yet --
+ * the caller selects that Page in the Builder. Nothing else is written from inside the update, so the
+ * Builder's own store is never patched from within the catalog's.
+ */
+export function applyPhiWorkspaceCatalogPreload(preload) {
+    let openedPageKey = null;
+    patchCatalog((current) => {
+        let changed = false;
+        const definitionsChanged = JSON.stringify(current.runtimeModuleDefinitions ?? []) !== preload.keys.runtimeModuleDefinitions;
+        const modulePresetPagesChanged = JSON.stringify(current.modulePresetPagesByArea) !== preload.keys.modulePresetPagesByArea;
+        const areaPresetSourcesChanged = JSON.stringify(current.areaPresetSourcesByArea) !== preload.keys.areaPresetSourcesByArea;
+        const navigationSurfacesChanged = JSON.stringify(current.navigationSurfacesByArea) !== preload.keys.navigationSurfacesByArea;
+        const unresolvedModuleIdsChanged = JSON.stringify(current.unresolvedModuleIdsByArea) !== preload.keys.unresolvedModuleIdsByArea;
+        const publicRouteClaimsChanged = JSON.stringify(current.publicRouteClaims) !== preload.keys.publicRouteClaims;
+        const serverUnavailableModulesChanged = JSON.stringify(current.serverUnavailableModules) !== preload.keys.serverUnavailableModules;
+        /*
+         * The assignments arrive with the Modules draft and are edited by the collision dialog, so this
+         * follows the same rule as the Module selection beside it: what the server sent replaces what is
+         * here when the server's answer changed, and an unsaved answer survives a re-render.
+         */
+        const publicRoutePathsChanged = JSON.stringify(current.publicRoutePaths) !== preload.keys.publicRoutePaths;
+        const catalogHydrationChanged = !current.catalogHydrated;
+        const initialPageKey = current.pageKey ||
+            resolvePhiBuilderActivePageKey(null, preload.activeCatalogs.modulePresetPagesByArea[current.area]) || "";
+        const initialPageChanged = initialPageKey !== current.pageKey;
+        const nextModuleIdsByArea = { ...(current.runtimeModuleIdsByArea ?? {}) };
+        for (const [area, moduleIds] of Object.entries(preload.runtimeModuleIdsByArea)) {
+            const builderArea = preload.normalizeArea(area);
+            if (JSON.stringify(nextModuleIdsByArea[builderArea] ?? []) !== JSON.stringify(moduleIds ?? [])) {
+                nextModuleIdsByArea[builderArea] = moduleIds;
+                changed = true;
+            }
+        }
+        openedPageKey = initialPageChanged ? initialPageKey : null;
+        return changed || definitionsChanged || modulePresetPagesChanged || areaPresetSourcesChanged ||
+            navigationSurfacesChanged || unresolvedModuleIdsChanged || serverUnavailableModulesChanged ||
+            publicRouteClaimsChanged || publicRoutePathsChanged || catalogHydrationChanged || initialPageChanged
+            ? {
+                ...current,
+                ...(initialPageChanged ? { pageKey: initialPageKey } : {}),
+                runtimeModuleDefinitions: [...preload.runtimeModuleDefinitions],
+                runtimeModuleIdsByArea: nextModuleIdsByArea,
+                catalogHydrated: true,
+                modulePresetPagesByArea: preload.activeCatalogs.modulePresetPagesByArea,
+                areaPresetSourcesByArea: preload.areaPresetSourcesByArea,
+                navigationSurfacesByArea: preload.activeCatalogs.navigationSurfacesByArea,
+                unresolvedModuleIdsByArea: preload.unresolvedModuleIdsByArea,
+                serverUnavailableModules: preload.serverUnavailableModules,
+                publicRouteClaims: preload.publicRouteClaims,
+                ...(publicRoutePathsChanged ? { publicRoutePaths: preload.publicRoutePaths } : {}),
+            }
+            : current;
+    });
+    return openedPageKey;
+}

package/plugins/runtime-modules/client-authoring-module.d.ts

@@ -28,4 +28,11 @@ export declare function createPhiRuntimeModuleAuthoringClient({ moduleId, Widget
     layouts?: readonly PhiAuthoringLayoutModuleLoader[];
 }): ComponentType<PhiRuntimeModuleAuthoringClientProps>;
 export declare function usePhiRuntimeModuleAuthoringRegistration(moduleId: PhiRuntimeModuleId | null | undefined): PhiRuntimeModuleAuthoringRegistration | null;
-export declare function usePhiAuthoringLayoutDefinition(type: string): PhiAuthoringLayoutDefinition | null;
+/**
+ * The authoring Layout definitions, as a lookup by type rather than one type's answer.
+ *
+ * A Layout names its nested Layouts only while it renders its children, and a parent Layout sizes each
+ * slot by the props of the element standing in it, before that element renders: a nested Layout's
+ * element has to carry its policy already, and a hook inside it would be too late.
+ */
+export declare function usePhiAuthoringLayoutDefinitionResolver(): (type: string) => PhiAuthoringLayoutDefinition | null;