@phis/ui 0.1.0

package/plugins/runtime-modules/builder/workspace-controller.js

@@ -0,0 +1,1940 @@
+"use client";
+import { useEffect, useEffectEvent, useMemo, useRef } from "react";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import { createPhiSignalAddress, createPhiSignalSubcontrolAddress, PHI_SIGNAL_VALUE_SCHEMAS } from "../../../types/signals";
+import { readPhiTableBindingParamsSignalValue } from "../../../types/table-widget";
+import { createPhiPresetCmsInstanceId, readPhiCmsInstanceId } from "../../../types/cms-instance-id";
+import { usePhiSignalDispatcher, usePhiSignalListener, } from "../../../components/runtime/runtime-signal-bus";
+import { usePhiApplicationFeedback } from "../../../components/runtime/use-phi-application-feedback";
+import { resolvePhiRuntimeModuleIdsForArea } from "../../../plugins/runtime-modules/settings";
+import { PHI_BUILDER_PREVIEW_SEARCH_PARAM, } from "./preview-transport";
+import { PHI_BUILDER_AREA_SEARCH_PARAM, PHI_BUILDER_NAVIGATION_KEY_SEARCH_PARAM, PHI_BUILDER_PAGE_SEARCH_PARAM, PHI_BUILDER_RUNTIME_MODULES_SEARCH_PARAM, normalizePhiBuilderAreaSearchParam, normalizePhiBuilderPageSearchParam, serializePhiBuilderRuntimeModuleIdsSearchParam, } from "../../../helpers/cms-scope-search-params";
+import { createPhiBuilderControllerAddress } from "./controller/address";
+import { readPhiBuilderInspectorAction, } from "./inspector-actions";
+import { createEmptyPhiBuilderModulePresetPagesByArea, resolvePhiBuilderActivePageCatalog, resolvePhiBuilderActivePageKey, resolvePhiBuilderPageKeyFromCatalogPath, } from "../../../helpers/cms-page-catalog";
+import { loadPhiBuilderPersistedPageCatalog } from "./page-catalog-client";
+import { resolvePhiBuilderOfferedPageKey, } from "./offered-page-catalog";
+import { isPhiBuilderAreaKey, resolvePhiBuilderAreaAsCmsArea, } from "../../../constants/cms-areas";
+import { resolvePhiRuntimeAreaDefinition } from "../../../plugins/runtime-modules/area-definitions";
+import { resolvePhiBuilderNavigationWidgetNavKey } from "./navigation-widget-runtime";
+import { parsePhiBuilderNavigationScopeKey } from "../../../helpers/cms-navigation-catalog";
+import { builderWorkspaceStore, usePhiDeveloperBuilderWorkspaceState, completePhiDeveloperBuilderEffectsEditor, createDefaultBuilderChromeControls, normalizePhiDeveloperBuilderArea as normalizeBuilderArea, selectPhiDeveloperBuilderNode, usePhiDeveloperRegionDraft, getPhiDeveloperBuilderStateSnapshot, setPhiDeveloperBuilderAreaRootRoute, readPhiBuilderEffectiveAreaRootRoute, setPhiDeveloperBuilderAreaRootRoutes, setPhiDeveloperBuilderAreaMeta, setPhiDeveloperBuilderAreaMetaBaseline, readPhiBuilderEffectiveAreaMeta, closePhiBuilderModuleDeactivationRequest, closePhiBuilderPublicRouteCollisionRequest, } from "./developer-workspace-store";
+import { PHI_BUILDER_AREA_LANDING_PAGE_EMPTY, PHI_BUILDER_AREA_ROOT_ROUTE_AUTOMATIC, PHI_BUILDER_AREA_ROOT_ROUTE_LANDING, } from "./options-providers";
+import { PHI_AREA_META_PUBLIC_DEFAULTS } from "../../../helpers/cms-area-config";
+import { getPhiBuilderRegionDraftKey } from "./region-keys";
+import { getDefaultRegionDraft } from "./developer-region-drafts";
+import { isPhiAreaScopedBuilderPage, isPhiDebugScaffoldBuilderPage, readPhiDeveloperBuilderWorkspaceKey, resolvePhiDeveloperBuilderCommandWorkspace, resolvePhiDeveloperBuilderRouteScope, } from "./route-scope";
+import { usePhiDeveloperBuilderPreviewModeController, } from "./preview-controller";
+import { runPhiDeveloperBuilderInspectorAction } from "./inspector-controller";
+import { PHI_BUILDER_SIGNAL_WIRING_FORM_CONTROLLER_ADDRESS, patchPhiBuilderSignalWiringSession, resetPhiBuilderSignalWiringSession, resolvePhiBuilderSignalWiringRoutes, resolvePhiBuilderSignalWiringRoutesWithout, } from "./signal-wiring-controller";
+import { readPhiTableActionSignalValue } from "../../../types/table-widget";
+import { usePhiBuilderPageController } from "./page-controller";
+import { PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS, PHI_BUILDER_INSPECTOR_DRAWER_OVERLAY_IDS, PHI_BUILDER_INSPECTOR_OVERLAY_IDS, PHI_BUILDER_INSPECTOR_WIDGET_IDS, } from "./inspector-overlay-addresses";
+import { PHI_BUILDER_MODULES_TABLE_WIDGET_ID, PHI_BUILDER_MODULE_DETAIL_OVERLAY_IDS, PHI_BUILDER_MODULE_DETAIL_WIDGET_IDS, PHI_BUILDER_PUBLIC_ROUTES_OVERLAY_IDS, PHI_BUILDER_PUBLIC_ROUTES_WIDGET_IDS, PHI_BUILDER_SHELLS_WIDGET_IDS, PHI_BUILDER_AREA_SETTINGS_OVERLAY_IDS, PHI_BUILDER_MODULE_USAGE_OVERLAY_IDS, PHI_BUILDER_MODULE_USAGE_WIDGET_IDS, } from "../../../helpers/cms-page-addresses";
+import { readPhiRuntimeFormValuesSignalValue } from "../../../components/forms/runtime-form-state";
+import { PHI_BUILDER_EFFECTS_SECTIONS, mergePhiBuilderEffectsFormValues, splitPhiBuilderEffectsFormValues, } from "./effects-form-values";
+import { usePhiBuilderDraftCommandController, } from "./draft-command-controller";
+import { applyPhiDeveloperBuilderSiderLeftMode, } from "./region-controller";
+import { createPhiBuilderHistoryContext, phiBuilderHistory, } from "./history";
+import { applyPhiBuilderRuntimeModuleSelectionChange, applyPhiBuilderRuntimeModuleSelectionChanges, areRuntimeModuleIdsEqual, } from "./runtime-module-selection";
+import { applyPhiBuilderPublicRouteAssignments, findPhiBuilderPublicRouteAnswerProblem, } from "./public-route-collisions";
+import { createPhiCommandToolbarControlAddress } from "../../../components/widgets/signals/command-toolbar-address";
+import { PHI_BUILDER_RUNTIME_MODULE_ID } from "../../../plugins/runtime-modules/builder/ids";
+import { createPhiRuntimeFormControllerAddress } from "../../../components/forms/runtime-form-controller-address";
+import { phiWorkspaceCatalogStore } from "../../../components/workspace/catalog-store";
+import { PHI_BUILDER_PAGE_META_DEFAULT_PRESENTATION_LABELS, } from "./controller/definition";
+const EMPTY_RUNTIME_MODULE_IDS_BY_AREA = {};
+const EMPTY_MODULE_PRESET_PAGES_BY_AREA = createEmptyPhiBuilderModulePresetPagesByArea();
+const EMPTY_PUBLIC_ROUTE_CLAIMS = [];
+const EMPTY_PUBLIC_ROUTE_PATHS = [];
+const EMPTY_AREA_ROOT_ROUTES = {};
+const EMPTY_AREA_META = {};
+function readPhiDeveloperBuilderToolbarCommand(value) {
+    if (value === "save" ||
+        value === "preview" ||
+        value === "publish" ||
+        value === "undo" ||
+        value === "redo" ||
+        value === "reset" ||
+        value === "restorePreset") {
+        return value;
+    }
+    return null;
+}
+function serializeRuntimeModuleIds(moduleIds) {
+    return JSON.stringify(moduleIds ?? []);
+}
+function serializeRuntimeModuleDefinitions(definitions) {
+    return JSON.stringify(definitions ?? []);
+}
+function selectRuntimeModuleIds(moduleIds, area, definitions) {
+    return resolvePhiRuntimeModuleIdsForArea(area, moduleIds, definitions);
+}
+function resolveBuilderActiveModuleIds(area, moduleIds, definitions) {
+    const cmsArea = resolvePhiBuilderAreaAsCmsArea(area);
+    const activeModuleIds = new Set([
+        resolvePhiRuntimeAreaDefinition(cmsArea).baseModuleId,
+        ...definitions
+            .filter((definition) => definition.kind === "platform")
+            .map((definition) => definition.moduleId),
+        ...selectRuntimeModuleIds(moduleIds, area, definitions),
+    ]);
+    return activeModuleIds;
+}
+function filterPresetPageNodes(nodes, activeModuleIds) {
+    return nodes.flatMap((node) => {
+        if (node.sourcePreset && !activeModuleIds.has(node.sourcePreset.ownerModuleId)) {
+            return [];
+        }
+        const children = filterPresetPageNodes(node.children ?? [], activeModuleIds);
+        if (!node.sourcePreset && node.children && children.length === 0) {
+            return [];
+        }
+        return [{ ...node, ...(node.children ? { children } : {}) }];
+    });
+}
+function filterNavigationItems(items, activeModuleIds) {
+    return items.flatMap((item) => {
+        if (item.ownerModuleId && !activeModuleIds.has(item.ownerModuleId)) {
+            return [];
+        }
+        return [{ ...item, children: filterNavigationItems(item.children, activeModuleIds) }];
+    });
+}
+function filterBuilderModuleCatalogs(modulePresetPagesByArea, navigationSurfacesByArea, runtimeModuleIdsByArea, definitions) {
+    const filteredPages = createEmptyPhiBuilderModulePresetPagesByArea();
+    const filteredNavigation = {};
+    for (const area of Object.keys(filteredPages)) {
+        const activeModuleIds = resolveBuilderActiveModuleIds(area, runtimeModuleIdsByArea[area], definitions);
+        filteredPages[area] = filterPresetPageNodes(modulePresetPagesByArea[area] ?? [], activeModuleIds);
+        filteredNavigation[area] = (navigationSurfacesByArea[area] ?? []).map((surface) => ({
+            ...surface,
+            items: filterNavigationItems(surface.items, activeModuleIds),
+        }));
+    }
+    return {
+        modulePresetPagesByArea: filteredPages,
+        navigationSurfacesByArea: filteredNavigation,
+    };
+}
+function usePhiDeveloperBuilderWorkspaceController(defaultArea, options = {}) {
+    const { showMessage } = usePhiApplicationFeedback();
+    const dispatchSignal = usePhiSignalDispatcher();
+    const effectsWorkflowCorrelationRef = useRef(null);
+    const initializedEffectsCorrelationRef = useRef(null);
+    const effectsFormSubmissionRef = useRef(null);
+    const { shellPresetDraftsByArea = {}, runtimeModuleDefinitions = [], runtimeModuleIdsByArea = {}, modulePresetPagesByArea = EMPTY_MODULE_PRESET_PAGES_BY_AREA, areaPresetSourcesByArea = {}, navigationSurfacesByArea = {}, unresolvedModuleIdsByArea = EMPTY_RUNTIME_MODULE_IDS_BY_AREA, publicRouteClaims = EMPTY_PUBLIC_ROUTE_CLAIMS, publicRoutePaths = EMPTY_PUBLIC_ROUTE_PATHS, areaRootRoutesByArea = EMPTY_AREA_ROOT_ROUTES, areaMetaByArea = EMPTY_AREA_META, pageMetaLabels = PHI_BUILDER_PAGE_META_DEFAULT_PRESENTATION_LABELS, } = options;
+    const state = usePhiDeveloperBuilderWorkspaceState(defaultArea);
+    const effectsOverlayAddress = createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_OVERLAY_IDS.effectsEditor);
+    const router = useRouter();
+    const pathname = usePathname();
+    const searchParams = useSearchParams();
+    const commandWorkspace = resolvePhiDeveloperBuilderCommandWorkspace(pathname);
+    const builderWorkspaceKey = readPhiDeveloperBuilderWorkspaceKey(pathname);
+    const isNavigationWorkspace = builderWorkspaceKey === "navigation";
+    const isBuilderWorkspace = builderWorkspaceKey !== null && builderWorkspaceKey !== "dashboard" &&
+        builderWorkspaceKey !== "settings";
+    const hasPreviewSnapshot = searchParams.has(PHI_BUILDER_PREVIEW_SEARCH_PARAM);
+    const scopeAreaFromSearch = normalizePhiBuilderAreaSearchParam(searchParams.get(PHI_BUILDER_AREA_SEARCH_PARAM));
+    const scopePageFromSearch = normalizePhiBuilderPageSearchParam(searchParams.get(PHI_BUILDER_PAGE_SEARCH_PARAM));
+    const { enterEditor, enterPreview } = usePhiDeveloperBuilderPreviewModeController(state);
+    const effectiveArea = scopeAreaFromSearch ?? state.area;
+    const effectivePageKey = scopePageFromSearch ?? state.pageKey;
+    const siderLeftDraftKey = getPhiBuilderRegionDraftKey(effectiveArea, "sider_left", effectivePageKey);
+    const siderLeftDraft = usePhiDeveloperRegionDraft(siderLeftDraftKey);
+    const resolvedSiderLeftDraft = siderLeftDraft ??
+        shellPresetDraftsByArea[effectiveArea]?.[siderLeftDraftKey] ??
+        getDefaultRegionDraft("sider_left");
+    const siderLeftFullHeight = resolvedSiderLeftDraft.regionConfig?.fullHeight === true;
+    const handledSiderLayoutRef = useRef(null);
+    const effectiveNavKey = resolvePhiBuilderNavigationWidgetNavKey(null, searchParams.get(PHI_BUILDER_NAVIGATION_KEY_SEARCH_PARAM), effectiveArea);
+    const { currentPageTree, emitPageTitleInputValue, navigateToBuilderPage, openPageMetaDialog, pageMetaDialog, } = usePhiBuilderPageController({
+        defaultArea,
+        effectiveArea,
+        effectivePageKey,
+        pageMetaLabels,
+        state,
+    });
+    const { confirmResetPage, runBuilderCommand } = usePhiBuilderDraftCommandController({
+        commandWorkspace,
+        defaultArea,
+        effectiveArea,
+        effectiveNavKey,
+        effectivePageKey,
+        pathname,
+        shellPresetDraftsByArea,
+        state,
+    });
+    const currentRuntimeModuleIdsByArea = state.runtimeModuleIdsByArea ?? EMPTY_RUNTIME_MODULE_IDS_BY_AREA;
+    const activePreloadCatalogs = useMemo(() => filterBuilderModuleCatalogs(modulePresetPagesByArea, navigationSurfacesByArea, runtimeModuleIdsByArea, runtimeModuleDefinitions), [
+        modulePresetPagesByArea,
+        navigationSurfacesByArea,
+        runtimeModuleDefinitions,
+        runtimeModuleIdsByArea,
+    ]);
+    const runtimeModuleIdsPreloadKey = serializeRuntimeModuleIds(Object.values(runtimeModuleIdsByArea).flat());
+    const runtimeModuleDefinitionsPreloadKey = serializeRuntimeModuleDefinitions(runtimeModuleDefinitions);
+    const modulePresetPagesPreloadKey = JSON.stringify(activePreloadCatalogs.modulePresetPagesByArea);
+    const areaPresetSourcesPreloadKey = JSON.stringify(areaPresetSourcesByArea);
+    const navigationSurfacesPreloadKey = JSON.stringify(activePreloadCatalogs.navigationSurfacesByArea);
+    const unresolvedModuleIdsPreloadKey = JSON.stringify(unresolvedModuleIdsByArea);
+    const publicRouteClaimsPreloadKey = JSON.stringify(publicRouteClaims);
+    const publicRoutePathsPreloadKey = JSON.stringify(publicRoutePaths);
+    const areaRootRoutesPreloadKey = JSON.stringify(areaRootRoutesByArea);
+    /*
+     * The Areas' root routes, handed to every workspace rather than to /shells alone.
+     *
+     * It is a baseline and not a draft: /pages reads it to leave `/` out of its page selector while the
+     * root forwards, and nothing about that is an edit.
+     */
+    useEffect(() => {
+        setPhiDeveloperBuilderAreaRootRoutes(areaRootRoutesByArea);
+        // The serialized preload is the identity that matters; the object is rebuilt on every render.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [areaRootRoutesPreloadKey]);
+    // What the Areas said about being found, read from the same revision and set the same way.
+    const areaMetaPreloadKey = JSON.stringify(areaMetaByArea);
+    useEffect(() => {
+        setPhiDeveloperBuilderAreaMetaBaseline(areaMetaByArea);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [areaMetaPreloadKey]);
+    const signalWiringOverlayAddress = createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_OVERLAY_IDS.signalWiring);
+    const signalWiringFormAddress = createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.signalWiringForm);
+    const openedSignalWiringCorrelationRef = useRef(null);
+    useEffect(() => {
+        const request = state.signalWiringRequest;
+        if (!request || openedSignalWiringCorrelationRef.current === request.correlationId) {
+            return;
+        }
+        openedSignalWiringCorrelationRef.current = request.correlationId;
+        // A wiring session belongs to the block it was opened on, so it starts empty every time.
+        resetPhiBuilderSignalWiringSession(defaultArea);
+        dispatchSignal({
+            scope: "area",
+            channel: "reset",
+            action: "activate",
+            value: null,
+            valueType: "none",
+            correlationId: request.correlationId,
+            sender: createPhiBuilderControllerAddress(),
+            receiver: signalWiringFormAddress,
+            timestamp: Date.now(),
+        });
+        // The Table is mounted eagerly with the overlay, so its rows may still belong to the block wired
+        // last time; opening on a new one has to ask for them again.
+        dispatchSignal({
+            scope: "area",
+            channel: "reload",
+            action: "activate",
+            value: null,
+            valueType: "none",
+            correlationId: request.correlationId,
+            sender: createPhiBuilderControllerAddress(),
+            receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.signalWiringRoutes),
+            timestamp: Date.now(),
+        });
+        queueMicrotask(() => dispatchSignal({
+            scope: "area",
+            channel: "dialog",
+            action: "activate",
+            value: null,
+            valueType: "none",
+            correlationId: request.correlationId,
+            sender: createPhiBuilderControllerAddress(),
+            receiver: signalWiringOverlayAddress,
+            timestamp: Date.now(),
+        }));
+    }, [defaultArea, dispatchSignal, signalWiringFormAddress, signalWiringOverlayAddress, state.signalWiringRequest]);
+    useEffect(() => {
+        const request = state.effectsEditorRequest;
+        if (!request || initializedEffectsCorrelationRef.current === request.correlationId)
+            return;
+        effectsWorkflowCorrelationRef.current = request.correlationId;
+        initializedEffectsCorrelationRef.current = request.correlationId;
+        const valuesBySection = splitPhiBuilderEffectsFormValues(request.effects);
+        for (const section of PHI_BUILDER_EFFECTS_SECTIONS) {
+            const widgetId = PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS[section];
+            dispatchSignal({
+                scope: "area",
+                channel: "values",
+                action: "change",
+                value: { values: valuesBySection[section] },
+                valueType: "json",
+                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.formValues,
+                correlationId: request.correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiRuntimeFormControllerAddress(`widget-${widgetId}`),
+                timestamp: Date.now(),
+            });
+        }
+        queueMicrotask(() => dispatchSignal({
+            scope: "area",
+            channel: "dialog",
+            action: "activate",
+            value: null,
+            valueType: "none",
+            correlationId: request.correlationId,
+            sender: createPhiBuilderControllerAddress(),
+            receiver: effectsOverlayAddress,
+            timestamp: Date.now(),
+        }));
+    }, [dispatchSignal, effectsOverlayAddress, state.effectsEditorRequest]);
+    /*
+     * The collision dialog follows the request rather than a click.
+     *
+     * A Module's switch opens the question and applies nothing; this turns the question into an open
+     * modal once the overlay is listening, and closes it again when the request is gone -- answered,
+     * cancelled, or replaced by the next one. Keeping the open state derived is what makes cancelling
+     * leave the Site exactly as it was: there is only ever the request to undo.
+     */
+    const publicRoutesOverlayAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_PUBLIC_ROUTES_OVERLAY_IDS.overlayPublicRoutes), []);
+    const publicRoutesTableAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_PUBLIC_ROUTES_WIDGET_IDS.publicRoutesTable), []);
+    /*
+     * The other half of the same switch: what turning a Module off stops drawing.
+     *
+     * Opened the same way and for the same reason -- nothing is applied while it stands -- so both
+     * directions of one gesture behave alike: a question that must be answered, a consequence that must
+     * be acknowledged.
+     */
+    const moduleUsageOverlayAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_MODULE_USAGE_OVERLAY_IDS.overlayModuleUsage), []);
+    const moduleUsageTableAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_MODULE_USAGE_WIDGET_IDS.moduleUsageTable), []);
+    const openedModuleUsageCorrelationRef = useRef(null);
+    const moduleDeactivationRequest = state.moduleDeactivationRequest;
+    useEffect(() => {
+        const correlationId = moduleDeactivationRequest?.correlationId ?? null;
+        if (openedModuleUsageCorrelationRef.current === correlationId) {
+            return;
+        }
+        openedModuleUsageCorrelationRef.current = correlationId;
+        dispatchSignal({
+            scope: "page",
+            channel: "moduleUsageDialog",
+            action: correlationId ? "activate" : "close",
+            value: null,
+            valueType: "none",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: moduleUsageOverlayAddress,
+            timestamp: Date.now(),
+        });
+        if (correlationId) {
+            dispatchSignal({
+                scope: "page",
+                channel: "reload",
+                action: "activate",
+                value: null,
+                valueType: "none",
+                sender: createPhiBuilderControllerAddress(),
+                receiver: moduleUsageTableAddress,
+                timestamp: Date.now(),
+            });
+        }
+    }, [
+        dispatchSignal,
+        moduleDeactivationRequest,
+        moduleUsageOverlayAddress,
+        moduleUsageTableAddress,
+    ]);
+    /*
+     * Whether the landing Select can be answered at all.
+     *
+     * A Select emits its value as a string and nothing turns "the value is landing" into the boolean the
+     * enabled channel carries, so the controller says it: the capability is the one every renderable
+     * block inherits, and the Select only had to listen. Sent on mount as well as on every change,
+     * because a workspace that opens with the root forwarding must not start out answerable.
+     */
+    const landingSelectAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_SHELLS_WIDGET_IDS.widgetAreaLandingPage), []);
+    /*
+     * Answerable whenever the root is a landing, and not only when somebody offers one.
+     *
+     * "None -- I will author it myself" is one of the answers, so there is always something to say. The
+     * older rule asked whether any Page carried the application flag, which after built-in Pages stopped
+     * applying left the Select switched off for good in an Area whose landing nobody had applied for.
+     */
+    const landingSelectEnabled = readPhiBuilderEffectiveAreaRootRoute(state, state.area)?.mode === "landing";
+    /*
+     * Said in the Select's own scope, and said once.
+     *
+     * The workspace header belongs to the Page, so the Select is registered as a Page-scoped receiver;
+     * an Area-scoped signal to it is not late, it is wrong, and the bus drops it rather than holding
+     * it. Held is what happens with the right scope: the controller mounts before the Control's chunk
+     * arrives, and the bus keeps the statement until somebody is there to hear it.
+     */
+    useEffect(() => {
+        dispatchSignal({
+            scope: "page",
+            channel: "enabled",
+            action: "change",
+            value: landingSelectEnabled,
+            valueType: "boolean",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: landingSelectAddress,
+            timestamp: Date.now(),
+        });
+    }, [dispatchSignal, landingSelectAddress, landingSelectEnabled]);
+    /*
+     * What the Area currently says about being found, and whether it may be answered here.
+     *
+     * Only Public is ever asked: every other Area is authenticated and is not indexed whatever is
+     * stored, so its switches stand at the Public default and are shown as unanswerable rather than
+     * hidden -- the dialog is the same dialog in every Area, and a control that vanishes reads as a
+     * feature that is missing. Said in the switches' own Page scope, for the reason the landing Select
+     * is: the workspace header belongs to the Page.
+     */
+    const seoIndexAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_SHELLS_WIDGET_IDS.widgetAreaSeoIndex), []);
+    const seoSitemapAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_SHELLS_WIDGET_IDS.widgetAreaSeoSitemap), []);
+    const titleTemplateAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_SHELLS_WIDGET_IDS.widgetAreaTitleTemplate), []);
+    const defaultTitleAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_SHELLS_WIDGET_IDS.widgetAreaDefaultTitle), []);
+    const areaMeta = readPhiBuilderEffectiveAreaMeta(state, state.area);
+    const seoAnswerable = state.area === "public";
+    // Outside Public the switches state the fact rather than the default: those Areas are not indexed
+    // and are in no sitemap, whatever a stored value from some earlier Area would suggest.
+    const seoIndex = seoAnswerable && (areaMeta?.index ?? PHI_AREA_META_PUBLIC_DEFAULTS.index);
+    const seoSitemap = seoAnswerable && (areaMeta?.sitemap ?? PHI_AREA_META_PUBLIC_DEFAULTS.sitemap);
+    /*
+     * The titles are stated in every Area, unlike the switches: a tab title is not a search result, and
+     * the Admin's own answer is as real as the Site's. Empty is a full answer here -- it says "the
+     * Site's name" -- so it is sent rather than withheld, or a field would keep what the Area shown
+     * before it had in it.
+     */
+    const titleTemplate = areaMeta?.titleTemplate ?? "";
+    const defaultTitle = areaMeta?.defaultTitle ?? "";
+    /**
+     * Everything the Area settings dialog shows, said in one place.
+     *
+     * Called from two moments, and it has to be both. The effect below covers a value that changes while
+     * the dialog stands open -- an undo, a switch between Areas. The dialog opening covers the far more
+     * common case: the controls live inside an Overlay and do not exist until it opens, so the state
+     * this controller stated at page load reached nobody. A signal is delivered once and is then spent;
+     * the mount that comes minutes later hears nothing, and the control would show its resting value as
+     * though it were the Area's answer.
+     */
+    const publishAreaSettingsState = (correlationId) => {
+        for (const [receiver, checked] of [
+            [seoIndexAddress, seoIndex],
+            [seoSitemapAddress, seoSitemap],
+        ]) {
+            dispatchSignal({
+                scope: "page",
+                channel: "seoValue",
+                action: "change",
+                value: checked,
+                valueType: "boolean",
+                sender: createPhiBuilderControllerAddress(),
+                receiver,
+                ...(correlationId ? { correlationId } : {}),
+                timestamp: Date.now(),
+            });
+            dispatchSignal({
+                scope: "page",
+                channel: "enabled",
+                action: "change",
+                value: seoAnswerable,
+                valueType: "boolean",
+                sender: createPhiBuilderControllerAddress(),
+                receiver,
+                ...(correlationId ? { correlationId } : {}),
+                timestamp: Date.now(),
+            });
+        }
+        for (const [receiver, text] of [
+            [titleTemplateAddress, titleTemplate],
+            [defaultTitleAddress, defaultTitle],
+        ]) {
+            dispatchSignal({
+                scope: "page",
+                channel: "titleValue",
+                action: "change",
+                value: text,
+                valueType: "string",
+                sender: createPhiBuilderControllerAddress(),
+                receiver,
+                ...(correlationId ? { correlationId } : {}),
+                timestamp: Date.now(),
+            });
+        }
+    };
+    const publishAreaSettingsStateEvent = useEffectEvent(publishAreaSettingsState);
+    useEffect(() => {
+        publishAreaSettingsStateEvent();
+    }, [defaultTitle, seoAnswerable, seoIndex, seoSitemap, titleTemplate]);
+    /*
+     * The Area settings dialog, opened and closed by the two commands that ask for it.
+     *
+     * No state of its own: unlike the two Modules dialogs there is no question waiting to be answered
+     * here -- every control inside writes into the draft the moment it is answered, exactly as it did
+     * while it stood in the header -- so the dialog is only a place, and the commands are the whole of
+     * its lifecycle.
+     */
+    const areaSettingsOverlayAddress = useMemo(() => createPhiSignalAddress("cms", PHI_BUILDER_AREA_SETTINGS_OVERLAY_IDS.overlayAreaSettings), []);
+    const dispatchAreaSettingsDialog = (open, correlationId) => {
+        dispatchSignal({
+            scope: "page",
+            channel: "areaSettingsDialog",
+            action: open ? "activate" : "close",
+            value: null,
+            valueType: "none",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: areaSettingsOverlayAddress,
+            correlationId,
+            timestamp: Date.now(),
+        });
+    };
+    const openedPublicRoutesCorrelationRef = useRef(null);
+    const publicRouteCollisionRequest = state.publicRouteCollisionRequest;
+    useEffect(() => {
+        const correlationId = publicRouteCollisionRequest?.correlationId ?? null;
+        if (openedPublicRoutesCorrelationRef.current === correlationId) {
+            return;
+        }
+        openedPublicRoutesCorrelationRef.current = correlationId;
+        dispatchSignal({
+            scope: "page",
+            channel: "publicRoutesDialog",
+            action: correlationId ? "activate" : "close",
+            value: null,
+            valueType: "none",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: publicRoutesOverlayAddress,
+            timestamp: Date.now(),
+        });
+        if (correlationId) {
+            /*
+             * And a re-read afterwards, not before: the rows live inside the overlay body, which mounts when
+             * the modal opens and is kept mounted after -- so a second question would otherwise show the
+             * first one's rows.
+             */
+            dispatchSignal({
+                scope: "page",
+                channel: "reload",
+                action: "activate",
+                value: null,
+                valueType: "none",
+                sender: createPhiBuilderControllerAddress(),
+                receiver: publicRoutesTableAddress,
+                timestamp: Date.now(),
+            });
+        }
+    }, [
+        dispatchSignal,
+        publicRouteCollisionRequest,
+        publicRoutesOverlayAddress,
+        publicRoutesTableAddress,
+    ]);
+    useEffect(() => {
+        const selectedOverlayId = state.nodeKind === "region"
+            ? PHI_BUILDER_INSPECTOR_OVERLAY_IDS.regionInspector
+            : state.nodeKind === "layout"
+                ? PHI_BUILDER_INSPECTOR_OVERLAY_IDS.layoutInspector
+                : state.nodeKind === "widget"
+                    ? PHI_BUILDER_INSPECTOR_OVERLAY_IDS.widgetInspector
+                    : null;
+        for (const overlayId of PHI_BUILDER_INSPECTOR_DRAWER_OVERLAY_IDS) {
+            dispatchSignal({
+                scope: "area",
+                channel: "dialog",
+                action: state.inspectorOpen && overlayId === selectedOverlayId ? "activate" : "close",
+                value: null,
+                valueType: "none",
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", overlayId),
+                timestamp: Date.now(),
+            });
+        }
+    }, [dispatchSignal, state.inspectorOpen, state.nodeKind]);
+    useEffect(() => {
+        /*
+         * Feeding the catalog is the Builder's job, but the catalog itself is not the Builder's state --
+         * it lives in the Foundation so that revisions, and later the Editor, can read it without going
+         * through here.
+         */
+        phiWorkspaceCatalogStore.patch(defaultArea, (current) => {
+            let changed = false;
+            const definitionsChanged = serializeRuntimeModuleDefinitions(current.runtimeModuleDefinitions) !== runtimeModuleDefinitionsPreloadKey;
+            const modulePresetPagesChanged = JSON.stringify(current.modulePresetPagesByArea) !== modulePresetPagesPreloadKey;
+            const areaPresetSourcesChanged = JSON.stringify(current.areaPresetSourcesByArea) !== areaPresetSourcesPreloadKey;
+            const navigationSurfacesChanged = JSON.stringify(current.navigationSurfacesByArea) !== navigationSurfacesPreloadKey;
+            const unresolvedModuleIdsChanged = JSON.stringify(current.unresolvedModuleIdsByArea) !== unresolvedModuleIdsPreloadKey;
+            const publicRouteClaimsChanged = JSON.stringify(current.publicRouteClaims) !== publicRouteClaimsPreloadKey;
+            /*
+             * 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) !== publicRoutePathsPreloadKey;
+            const catalogHydrationChanged = !current.catalogHydrated;
+            const initialPageKey = current.pageKey ||
+                resolvePhiBuilderActivePageKey(null, activePreloadCatalogs.modulePresetPagesByArea[current.area]) || "";
+            const initialPageChanged = initialPageKey !== current.pageKey;
+            const nextModuleIdsByArea = {
+                ...(current.runtimeModuleIdsByArea ?? {}),
+            };
+            for (const [area, moduleIds] of Object.entries(runtimeModuleIdsByArea)) {
+                const builderArea = normalizeBuilderArea(area);
+                if (!areRuntimeModuleIdsEqual(nextModuleIdsByArea[builderArea], moduleIds)) {
+                    nextModuleIdsByArea[builderArea] = moduleIds;
+                    changed = true;
+                }
+            }
+            if (initialPageChanged) {
+                // The selected node follows the page, and that selection is Builder tool state.
+                builderWorkspaceStore.patch(defaultArea, (tool) => ({
+                    ...tool,
+                    nodeKey: `page:${initialPageKey}`,
+                }));
+            }
+            return changed || definitionsChanged || modulePresetPagesChanged || areaPresetSourcesChanged || navigationSurfacesChanged || unresolvedModuleIdsChanged || publicRouteClaimsChanged || publicRoutePathsChanged || catalogHydrationChanged || initialPageChanged
+                ? {
+                    ...current,
+                    ...(initialPageChanged ? { pageKey: initialPageKey } : {}),
+                    runtimeModuleDefinitions: [...runtimeModuleDefinitions],
+                    runtimeModuleIdsByArea: nextModuleIdsByArea,
+                    catalogHydrated: true,
+                    modulePresetPagesByArea: activePreloadCatalogs.modulePresetPagesByArea,
+                    areaPresetSourcesByArea,
+                    navigationSurfacesByArea: activePreloadCatalogs.navigationSurfacesByArea,
+                    unresolvedModuleIdsByArea,
+                    publicRouteClaims,
+                    ...(publicRoutePathsChanged ? { publicRoutePaths } : {}),
+                }
+                : current;
+        });
+    }, [
+        defaultArea,
+        runtimeModuleDefinitions,
+        runtimeModuleDefinitionsPreloadKey,
+        runtimeModuleIdsByArea,
+        runtimeModuleIdsPreloadKey,
+        modulePresetPagesByArea,
+        modulePresetPagesPreloadKey,
+        unresolvedModuleIdsByArea,
+        unresolvedModuleIdsPreloadKey,
+        publicRouteClaims,
+        publicRouteClaimsPreloadKey,
+        publicRoutePaths,
+        publicRoutePathsPreloadKey,
+        areaPresetSourcesByArea,
+        areaPresetSourcesPreloadKey,
+        activePreloadCatalogs,
+        navigationSurfacesByArea,
+        navigationSurfacesPreloadKey,
+    ]);
+    useEffect(() => {
+        if (!isBuilderWorkspace ||
+            !state.catalogHydrated ||
+            state.pageCatalogHydratedByArea[effectiveArea]) {
+            return;
+        }
+        let cancelled = false;
+        void loadPhiBuilderPersistedPageCatalog(effectiveArea)
+            .then((pages) => {
+            if (cancelled)
+                return;
+            phiWorkspaceCatalogStore.patch(defaultArea, (current) => ({
+                ...current,
+                persistedPageCatalogByArea: {
+                    ...current.persistedPageCatalogByArea,
+                    [effectiveArea]: pages,
+                },
+                pageCatalogHydratedByArea: {
+                    ...current.pageCatalogHydratedByArea,
+                    [effectiveArea]: true,
+                },
+            }));
+        })
+            .catch((error) => {
+            if (!cancelled) {
+                showMessage({
+                    level: "error",
+                    content: error instanceof Error ? error.message : "Failed to load page catalog.",
+                });
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        defaultArea,
+        effectiveArea,
+        isBuilderWorkspace,
+        showMessage,
+        state.catalogHydrated,
+        state.pageCatalogHydratedByArea,
+    ]);
+    const currentRuntimeModuleIdsKey = JSON.stringify(currentRuntimeModuleIdsByArea);
+    useEffect(() => {
+        const activeCatalogs = filterBuilderModuleCatalogs(modulePresetPagesByArea, navigationSurfacesByArea, currentRuntimeModuleIdsByArea, runtimeModuleDefinitions);
+        phiWorkspaceCatalogStore.patch(defaultArea, (current) => {
+            if (JSON.stringify(current.modulePresetPagesByArea) ===
+                JSON.stringify(activeCatalogs.modulePresetPagesByArea) &&
+                JSON.stringify(current.navigationSurfacesByArea) ===
+                    JSON.stringify(activeCatalogs.navigationSurfacesByArea)) {
+                return current;
+            }
+            return {
+                ...current,
+                modulePresetPagesByArea: activeCatalogs.modulePresetPagesByArea,
+                navigationSurfacesByArea: activeCatalogs.navigationSurfacesByArea,
+            };
+        });
+    }, [
+        currentRuntimeModuleIdsByArea,
+        currentRuntimeModuleIdsKey,
+        defaultArea,
+        modulePresetPagesByArea,
+        navigationSurfacesByArea,
+        runtimeModuleDefinitions,
+        runtimeModuleDefinitionsPreloadKey,
+    ]);
+    const selectedRuntimeModuleIds = useMemo(() => selectRuntimeModuleIds(currentRuntimeModuleIdsByArea[effectiveArea], effectiveArea, runtimeModuleDefinitions), [currentRuntimeModuleIdsByArea, effectiveArea, runtimeModuleDefinitions]);
+    const selectedRuntimeModuleIdsSearchValue = serializePhiBuilderRuntimeModuleIdsSearchParam(selectedRuntimeModuleIds);
+    /*
+     * The Pages workspace derives which Pages are visible from which Modules are active, so an unsaved
+     * Module change has to reach it even though the change itself is made and persisted from elsewhere --
+     * the URL is what carries it across that gap.
+     */
+    useEffect(() => {
+        if (typeof pathname !== "string" ||
+            (builderWorkspaceKey !== "shells" && builderWorkspaceKey !== "pages") ||
+            searchParams.get(PHI_BUILDER_RUNTIME_MODULES_SEARCH_PARAM) === selectedRuntimeModuleIdsSearchValue) {
+            return;
+        }
+        const nextSearchParams = new URLSearchParams(searchParams.toString());
+        nextSearchParams.set(PHI_BUILDER_RUNTIME_MODULES_SEARCH_PARAM, selectedRuntimeModuleIdsSearchValue);
+        router.replace(`${pathname}?${nextSearchParams.toString()}`, { scroll: false });
+    }, [builderWorkspaceKey, pathname, router, searchParams, selectedRuntimeModuleIdsSearchValue]);
+    useEffect(() => {
+        if (builderWorkspaceKey !== "shells") {
+            return;
+        }
+        const handledSiderLayout = handledSiderLayoutRef.current;
+        if (handledSiderLayout?.draftKey === siderLeftDraftKey &&
+            handledSiderLayout.fullHeight === siderLeftFullHeight) {
+            handledSiderLayoutRef.current = null;
+            return;
+        }
+        dispatchSignal({
+            scope: "area",
+            channel: "layout",
+            action: "change",
+            value: siderLeftFullHeight,
+            valueType: "boolean",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: "broadcast",
+            timestamp: Date.now(),
+        });
+    }, [
+        builderWorkspaceKey,
+        dispatchSignal,
+        pathname,
+        siderLeftDraftKey,
+        siderLeftFullHeight,
+    ]);
+    useEffect(() => {
+        if (state.commandWorkspace === commandWorkspace) {
+            return;
+        }
+        builderWorkspaceStore.patch(defaultArea, (current) => ({
+            ...current,
+            commandWorkspace,
+            builderChromeControls: createDefaultBuilderChromeControls(),
+        }));
+    }, [commandWorkspace, defaultArea, state.commandWorkspace]);
+    useEffect(() => {
+        if (commandWorkspace !== "structure" &&
+            commandWorkspace !== "pages" &&
+            commandWorkspace !== "navigation" &&
+            commandWorkspace !== "modules") {
+            return;
+        }
+        const historyContext = createPhiBuilderHistoryContext({
+            workspace: commandWorkspace,
+            area: effectiveArea,
+            pageKey: effectivePageKey,
+            navKey: effectiveNavKey,
+        });
+        const presetKey = commandWorkspace === "structure"
+            ? "builder-shells-page"
+            : commandWorkspace === "pages"
+                ? "builder-pages-page"
+                : commandWorkspace === "modules"
+                    ? "builder-modules-page"
+                    : "builder-navigation-page";
+        const emitAvailability = () => {
+            const availability = phiBuilderHistory.getAvailability(historyContext);
+            for (const [controlKey, enabled] of [
+                ["undo", availability.canUndo],
+                ["redo", availability.canRedo],
+            ]) {
+                dispatchSignal({
+                    scope: "area",
+                    channel: "enabled",
+                    action: "change",
+                    value: enabled,
+                    valueType: "boolean",
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiCommandToolbarControlAddress(PHI_BUILDER_RUNTIME_MODULE_ID, presetKey, controlKey),
+                    timestamp: Date.now(),
+                });
+            }
+        };
+        emitAvailability();
+        return phiBuilderHistory.subscribe(historyContext, emitAvailability);
+    }, [
+        commandWorkspace,
+        dispatchSignal,
+        effectiveArea,
+        effectiveNavKey,
+        effectivePageKey,
+    ]);
+    useEffect(() => {
+        if (!isBuilderWorkspace) {
+            return;
+        }
+        const nextBuilderMode = !isNavigationWorkspace && hasPreviewSnapshot ? "preview" : "editor";
+        if (state.builderMode === nextBuilderMode) {
+            return;
+        }
+        builderWorkspaceStore.patch(defaultArea, (current) => ({
+            ...current,
+            builderMode: nextBuilderMode,
+        }));
+    }, [defaultArea, hasPreviewSnapshot, isBuilderWorkspace, isNavigationWorkspace, state.builderMode]);
+    /*
+     * The workspace, narrowed to what deciding the offered Pages actually reads.
+     *
+     * The effect below used to be handed the state whole, which asks it to re-run on every unrelated
+     * store change and made its dependency list a copy of the offered catalog's own field list, kept by
+     * hand. Naming the same Pick the resolver names keeps the two together: what the Area's Page list
+     * depends on is stated once, and a field added there arrives here without anybody remembering to.
+     *
+     * The unsaved root route is deliberately absent, because the Page list does not follow it: what
+     * `/pages` may open is what the Area has stored, which is what the server serves.
+     */
+    const offeredCatalogState = useMemo(() => ({
+        modulePresetPagesByArea: state.modulePresetPagesByArea,
+        customPages: state.customPages,
+        persistedPageCatalogByArea: state.persistedPageCatalogByArea,
+        navigationSurfacesByArea: state.navigationSurfacesByArea,
+        runtimeModuleIdsByArea: state.runtimeModuleIdsByArea,
+        areaRootRoutes: state.areaRootRoutes,
+    }), [
+        state.modulePresetPagesByArea,
+        state.customPages,
+        state.persistedPageCatalogByArea,
+        state.navigationSurfacesByArea,
+        state.runtimeModuleIdsByArea,
+        state.areaRootRoutes,
+    ]);
+    useEffect(() => {
+        if (!isBuilderWorkspace || !state.pageCatalogHydratedByArea[effectiveArea]) {
+            return;
+        }
+        if (scopeAreaFromSearch == null || scopePageFromSearch == null) {
+            if (typeof pathname !== "string") {
+                return;
+            }
+            const canonicalArea = scopeAreaFromSearch ?? state.area;
+            const { pageKey: canonicalPageKey } = resolvePhiBuilderOfferedPageKey(offeredCatalogState, canonicalArea, scopePageFromSearch ??
+                (scopeAreaFromSearch != null && scopeAreaFromSearch !== state.area ? null : state.pageKey));
+            if (!canonicalPageKey) {
+                return;
+            }
+            const nextSearchParams = new URLSearchParams(searchParams.toString());
+            nextSearchParams.set(PHI_BUILDER_AREA_SEARCH_PARAM, canonicalArea);
+            nextSearchParams.set(PHI_BUILDER_PAGE_SEARCH_PARAM, canonicalPageKey);
+            router.replace(`${pathname}?${nextSearchParams.toString()}`, { scroll: false });
+            return;
+        }
+        const nextArea = scopeAreaFromSearch ?? state.area;
+        /*
+         * The Page the address names, if the Area still offers it -- otherwise the one the shared order
+         * picks.
+         *
+         * A Page can stop being on offer without anybody navigating: setting the Area root to forward
+         * takes `/` out of the Builder's list, and whoever was standing on it is then parked on a Page
+         * that must not be authored, because a revision stored there would switch the forward off. So the
+         * key is normalised on every read of the address rather than only when the Area changes.
+         */
+        const { pageKey: nextPageKey } = resolvePhiBuilderOfferedPageKey(offeredCatalogState, nextArea, scopePageFromSearch ??
+            (scopeAreaFromSearch != null && scopeAreaFromSearch !== state.area ? null : state.pageKey));
+        if (!nextPageKey) {
+            return;
+        }
+        /*
+         * A normalised key is written back to the address, not only into the state: the address is what a
+         * reload and a copied link read, and leaving it pointing at a Page the Builder has moved off would
+         * make it move again on every open.
+         */
+        if (nextPageKey !== scopePageFromSearch && typeof pathname === "string") {
+            const correctedSearchParams = new URLSearchParams(searchParams.toString());
+            correctedSearchParams.set(PHI_BUILDER_AREA_SEARCH_PARAM, nextArea);
+            correctedSearchParams.set(PHI_BUILDER_PAGE_SEARCH_PARAM, nextPageKey);
+            router.replace(`${pathname}?${correctedSearchParams.toString()}`, { scroll: false });
+            return;
+        }
+        if (nextArea === state.area && nextPageKey === state.pageKey) {
+            return;
+        }
+        phiWorkspaceCatalogStore.patch(defaultArea, (current) => ({
+            ...current,
+            area: nextArea,
+            pageKey: nextPageKey,
+        }));
+        builderWorkspaceStore.patch(defaultArea, (current) => ({
+            ...current,
+            nodeKey: `page:${nextPageKey}`,
+            nodeId: null,
+            nodeKind: "page",
+            selectedRegionType: null,
+            selectedRegionKey: null,
+            selectedRootRegionKey: null,
+            inspectorOpen: false,
+            sidebarKey: "pages",
+            builderChromeControls: createDefaultBuilderChromeControls(),
+        }));
+    }, [
+        defaultArea,
+        isBuilderWorkspace,
+        offeredCatalogState,
+        pathname,
+        router,
+        searchParams,
+        scopeAreaFromSearch,
+        scopePageFromSearch,
+        state.area,
+        state.pageCatalogHydratedByArea,
+        state.pageKey,
+        effectiveArea,
+    ]);
+    usePhiSignalListener((signal) => {
+        const effectsRequest = state.effectsEditorRequest;
+        if (effectsRequest &&
+            signal.correlationId === effectsRequest.correlationId &&
+            signal.channel === "effectsCommit" &&
+            signal.action === "change" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.formValues) {
+            const submitted = readPhiRuntimeFormValuesSignalValue(signal.value);
+            const nextEffects = submitted?.values.effects;
+            completePhiDeveloperBuilderEffectsEditor(defaultArea, effectsRequest, nextEffects && typeof nextEffects === "object" && !Array.isArray(nextEffects)
+                ? nextEffects
+                : undefined);
+            initializedEffectsCorrelationRef.current = null;
+            return;
+        }
+        if (effectsRequest &&
+            signal.correlationId === effectsRequest.correlationId &&
+            signal.channel === "effectsCancel" &&
+            signal.action === "close") {
+            completePhiDeveloperBuilderEffectsEditor(defaultArea, effectsRequest);
+            initializedEffectsCorrelationRef.current = null;
+            return;
+        }
+        if (signal.scope === "area" &&
+            signal.channel === "area" &&
+            signal.action === "change" &&
+            signal.valueType === "string" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            if (!isPhiBuilderAreaKey(signal.value)) {
+                return;
+            }
+            const nextArea = signal.value;
+            const nextPages = resolvePhiBuilderActivePageCatalog(nextArea, state.modulePresetPagesByArea, state.customPages ?? {}, state.persistedPageCatalogByArea);
+            // The first node that is a Page: with routes under their package the first root node is a folder.
+            const nextPageKey = resolvePhiBuilderActivePageKey(null, nextPages) ?? "";
+            if (typeof pathname === "string") {
+                const nextSearchParams = new URLSearchParams(searchParams.toString());
+                nextSearchParams.set(PHI_BUILDER_AREA_SEARCH_PARAM, nextArea);
+                nextSearchParams.set(PHI_BUILDER_PAGE_SEARCH_PARAM, nextPageKey);
+                nextSearchParams.set(PHI_BUILDER_RUNTIME_MODULES_SEARCH_PARAM, serializePhiBuilderRuntimeModuleIdsSearchParam(state.runtimeModuleIdsByArea[nextArea] ?? []));
+                router.replace(`${pathname}?${nextSearchParams.toString()}`, { scroll: false });
+            }
+            else {
+                phiWorkspaceCatalogStore.patch(defaultArea, (current) => ({
+                    ...current,
+                    area: nextArea,
+                    pageKey: nextPageKey,
+                }));
+                builderWorkspaceStore.patch(defaultArea, (current) => ({
+                    ...current,
+                    nodeKey: `page:${nextPageKey}`,
+                    nodeId: null,
+                    nodeKind: "page",
+                    selectedRegionType: null,
+                    selectedRegionKey: null,
+                    selectedRootRegionKey: null,
+                    inspectorOpen: false,
+                    sidebarKey: "pages",
+                }));
+            }
+            return;
+        }
+        if (signal.scope === "area" &&
+            signal.channel === "moduleUsage" &&
+            signal.action === "activate" &&
+            signal.valueType === "string" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            const request = state.moduleDeactivationRequest;
+            if (!request) {
+                return;
+            }
+            if (signal.value === "confirm") {
+                applyPhiBuilderRuntimeModuleSelectionChanges(request.areas.map((area) => ({
+                    area,
+                    selectedIds: (state.runtimeModuleIdsByArea?.[area] ?? [])
+                        .filter((moduleId) => moduleId !== request.moduleId),
+                })), defaultArea);
+                dispatchSignal({
+                    scope: "area",
+                    channel: "reload",
+                    action: "activate",
+                    value: null,
+                    valueType: "none",
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiSignalAddress("cms", PHI_BUILDER_MODULES_TABLE_WIDGET_ID),
+                    correlationId: signal.correlationId,
+                    timestamp: Date.now(),
+                });
+            }
+            closePhiBuilderModuleDeactivationRequest(defaultArea);
+            return;
+        }
+        /*
+         * The answer to the one question enabling a Module can ask.
+         *
+         * Assigning writes the addresses first and enables the Module in the same gesture, because a
+         * Module is active with every route addressed or it is not active. Cancelling writes nothing:
+         * the Module stays off, and the Site is where it was before the switch was touched.
+         */
+        if (signal.scope === "area" &&
+            signal.channel === "publicRoutes" &&
+            signal.action === "activate" &&
+            signal.valueType === "string" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            const request = state.publicRouteCollisionRequest;
+            if (!request) {
+                return;
+            }
+            if (signal.value === "cancel") {
+                closePhiBuilderPublicRouteCollisionRequest(defaultArea);
+                return;
+            }
+            if (signal.value !== "assign") {
+                return;
+            }
+            const rejection = findPhiBuilderPublicRouteAnswerProblem(state, request);
+            if (rejection) {
+                showMessage({ level: "error", content: rejection }, { correlationId: signal.correlationId });
+                return;
+            }
+            applyPhiBuilderPublicRouteAssignments(defaultArea, request);
+            applyPhiBuilderRuntimeModuleSelectionChanges(request.areas.map((area) => ({
+                area,
+                selectedIds: [...(state.runtimeModuleIdsByArea?.[area] ?? []), request.moduleId],
+            })), defaultArea);
+            closePhiBuilderPublicRouteCollisionRequest(defaultArea);
+            dispatchSignal({
+                scope: "area",
+                channel: "reload",
+                action: "activate",
+                value: null,
+                valueType: "none",
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_MODULES_TABLE_WIDGET_ID),
+                correlationId: signal.correlationId,
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.scope === "area" &&
+            signal.channel === "bindingParams" &&
+            signal.action === "change" &&
+            signal.valueType === "json" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.tableBindingParams &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            const binding = readPhiTableBindingParamsSignalValue(signal.value);
+            const navKey = typeof binding?.params.navKey === "string" ? binding.params.navKey : null;
+            const parsed = parsePhiBuilderNavigationScopeKey(navKey);
+            const current = getPhiDeveloperBuilderStateSnapshot(defaultArea);
+            const cmsArea = resolvePhiBuilderAreaAsCmsArea(current.area);
+            const normalizedNavKey = parsed ? `${parsed.area}:${parsed.key}` : null;
+            if (!parsed || parsed.area !== cmsArea ||
+                !normalizedNavKey ||
+                !(current.navigationSurfacesByArea[current.area] ?? []).some((surface) => surface.navKey === normalizedNavKey) ||
+                !pathname) {
+                return;
+            }
+            const nextSearchParams = new URLSearchParams(searchParams.toString());
+            nextSearchParams.set(PHI_BUILDER_AREA_SEARCH_PARAM, current.area);
+            nextSearchParams.set(PHI_BUILDER_PAGE_SEARCH_PARAM, current.pageKey);
+            nextSearchParams.set(PHI_BUILDER_NAVIGATION_KEY_SEARCH_PARAM, normalizedNavKey);
+            router.replace(`${pathname}?${nextSearchParams.toString()}`, { scroll: false });
+            return;
+        }
+        if (signal.channel === "builderChrome" && signal.action === "change") {
+            const nextControls = signal.value && typeof signal.value === "object"
+                ? signal.value
+                : null;
+            const currentRouteScope = resolvePhiDeveloperBuilderRouteScope(pathname);
+            if (!nextControls || !currentRouteScope || nextControls.area !== currentRouteScope.area || nextControls.pageKey !== currentRouteScope.pageKey) {
+                return;
+            }
+            const currentBuilderChromeControls = state.builderChromeControls ?? createDefaultBuilderChromeControls();
+            builderWorkspaceStore.patch(defaultArea, (current) => ({
+                ...current,
+                builderChromeControls: {
+                    editorPreviewDisabled: typeof nextControls.editorPreviewDisabled === "boolean"
+                        ? nextControls.editorPreviewDisabled
+                        : currentBuilderChromeControls.editorPreviewDisabled,
+                    actionsDisabled: typeof nextControls.actionsDisabled === "boolean"
+                        ? nextControls.actionsDisabled
+                        : currentBuilderChromeControls.actionsDisabled,
+                    debugDisabled: typeof nextControls.debugDisabled === "boolean"
+                        ? nextControls.debugDisabled
+                        : currentBuilderChromeControls.debugDisabled,
+                },
+            }));
+            return;
+        }
+        if (signal.scope === "page" && signal.channel === "path" && signal.action === "change") {
+            if (builderWorkspaceKey !== "pages" || typeof signal.value !== "string" || signal.value.length === 0) {
+                return;
+            }
+            const nextPageKey = resolvePhiBuilderPageKeyFromCatalogPath(effectiveArea, signal.value, currentPageTree);
+            if (!nextPageKey) {
+                return;
+            }
+            navigateToBuilderPage(nextPageKey);
+            emitPageTitleInputValue(nextPageKey);
+            return;
+        }
+        if (signal.channel === "page" && signal.action === "change") {
+            const rawValue = signal.value;
+            const next = rawValue && typeof rawValue === "object"
+                ? rawValue
+                : { value: rawValue };
+            if (!next) {
+                return;
+            }
+            const nextPageKey = typeof next.pageKey === "string" && next.pageKey.length > 0
+                ? next.pageKey
+                : typeof next.value === "string" && next.value.length > 0
+                    ? resolvePhiBuilderPageKeyFromCatalogPath(state.area, next.value, resolvePhiBuilderActivePageCatalog(state.area, state.modulePresetPagesByArea, state.customPages, state.persistedPageCatalogByArea))
+                    : null;
+            if (!nextPageKey) {
+                return;
+            }
+            if (builderWorkspaceKey === "pages") {
+                navigateToBuilderPage(nextPageKey);
+                emitPageTitleInputValue(nextPageKey);
+                return;
+            }
+            emitPageTitleInputValue(nextPageKey);
+            phiWorkspaceCatalogStore.patch(defaultArea, (current) => ({
+                ...current,
+                pageKey: nextPageKey,
+            }));
+            builderWorkspaceStore.patch(defaultArea, (current) => ({
+                ...current,
+                nodeKey: `page:${nextPageKey}`,
+                nodeId: null,
+                nodeKind: "page",
+                selectedRegionType: null,
+                selectedRegionKey: null,
+                selectedRootRegionKey: null,
+                inspectorOpen: false,
+                sidebarKey: "pages",
+                pagesOpen: false,
+                builderChromeControls: createDefaultBuilderChromeControls(),
+            }));
+            return;
+        }
+        const builderControllerReceiver = createPhiBuilderControllerAddress();
+        const targetsBuilderController = signal.receiver === builderControllerReceiver;
+        /*
+         * The Modules Table names a row, the detail Table needs binding params, and the overlay needs an
+         * open: three different value shapes, so the translation between them lives here rather than in a
+         * route the Table could carry on its own.
+         */
+        if (signal.scope === "area" &&
+            signal.channel === "action" &&
+            signal.action === "activate" &&
+            signal.valueType === "json" &&
+            signal.receiver === builderControllerReceiver &&
+            signal.sender === createPhiSignalAddress("cms", PHI_BUILDER_MODULES_TABLE_WIDGET_ID)) {
+            const tableAction = readPhiTableActionSignalValue(signal.value);
+            if (tableAction?.actionKey !== "details" || typeof tableAction.rowIdentity !== "string") {
+                return;
+            }
+            dispatchSignal({
+                scope: "page",
+                channel: "bindingParams",
+                action: "change",
+                value: { params: { moduleId: tableAction.rowIdentity } },
+                valueType: "json",
+                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.tableBindingParams,
+                correlationId: signal.correlationId,
+                sender: builderControllerReceiver,
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_MODULE_DETAIL_WIDGET_IDS.fields),
+                timestamp: Date.now(),
+            });
+            dispatchSignal({
+                scope: "page",
+                channel: "dialog",
+                action: "activate",
+                value: null,
+                valueType: "none",
+                correlationId: signal.correlationId,
+                sender: builderControllerReceiver,
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_MODULE_DETAIL_OVERLAY_IDS.overlayModuleDetail),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.scope === "area" &&
+            signal.channel === "runtimeModules" &&
+            signal.action === "change" &&
+            signal.valueType === "string[]" &&
+            signal.receiver === builderControllerReceiver &&
+            signal.sender !== builderControllerReceiver) {
+            const selectedIds = Array.isArray(signal.value)
+                ? signal.value.filter((value) => typeof value === "string")
+                : null;
+            if (!selectedIds) {
+                return;
+            }
+            try {
+                applyPhiBuilderRuntimeModuleSelectionChange(effectiveArea, selectedIds, defaultArea);
+            }
+            catch (error) {
+                showMessage({ level: "error", content: error instanceof Error ? error.message : "Invalid runtime module selection." }, { correlationId: signal.correlationId });
+            }
+            return;
+        }
+        if (signal.scope === "area" &&
+            signal.channel === "command" &&
+            signal.action === "activate" &&
+            signal.valueType === "string" &&
+            targetsBuilderController) {
+            const commandValue = signal.value;
+            if (builderWorkspaceKey === "pages") {
+                if (commandValue === "createPage") {
+                    openPageMetaDialog("create");
+                    return;
+                }
+                if (commandValue === "editPageMeta") {
+                    openPageMetaDialog("update");
+                    return;
+                }
+                if (commandValue === "deletePage") {
+                    confirmResetPage();
+                    return;
+                }
+            }
+            const command = readPhiDeveloperBuilderToolbarCommand(commandValue);
+            const commandWorkspace = state.commandWorkspace;
+            const builderChromeControls = state.builderChromeControls ?? createDefaultBuilderChromeControls();
+            if (!command || commandWorkspace == null || builderChromeControls.actionsDisabled) {
+                return;
+            }
+            runBuilderCommand(command);
+            return;
+        }
+        if (signal.channel === "debugScaffold" && signal.action === "change") {
+            const nextDebugScaffold = typeof signal.value === "boolean" ? signal.value : null;
+            if (nextDebugScaffold == null) {
+                return;
+            }
+            builderWorkspaceStore.patch(defaultArea, (current) => ({
+                ...current,
+                debugScaffold: nextDebugScaffold,
+            }));
+            return;
+        }
+        if (signal.channel === "content") {
+            const rawValue = signal.value;
+            const next = rawValue && typeof rawValue === "object" ? rawValue : null;
+            if (!next || next.nodeKind !== "region" || typeof next.regionKey !== "string" || !next.draft || typeof next.draft !== "object") {
+                return;
+            }
+            const regionKey = next.regionKey;
+            const nextDraft = next.draft;
+            const catalog = phiWorkspaceCatalogStore.getSnapshot(defaultArea);
+            const nextArea = typeof next.area === "string" ? next.area : catalog.area;
+            const nextPageKey = typeof next.pageKey === "string" && next.pageKey.length > 0 ? next.pageKey : catalog.pageKey;
+            builderWorkspaceStore.patch(defaultArea, (current) => {
+                return {
+                    ...current,
+                    regionDrafts: {
+                        ...current.regionDrafts,
+                        [getPhiBuilderRegionDraftKey(nextArea, regionKey, nextPageKey)]: nextDraft,
+                    },
+                };
+            });
+            return;
+        }
+        if (signal.channel === "selection" && signal.action === "change") {
+            const rawValue = signal.value;
+            const next = rawValue && typeof rawValue === "object" ? rawValue : null;
+            if (!next || typeof next.nodeKey !== "string" || typeof next.nodeKind !== "string") {
+                return;
+            }
+            const nextNodeKey = next.nodeKey;
+            const nextPageKey = typeof next.pageKey === "string" ? next.pageKey : undefined;
+            selectPhiDeveloperBuilderNode(defaultArea, {
+                ...(typeof next.area === "string" ? { area: next.area } : {}),
+                ...(nextPageKey ? { pageKey: nextPageKey } : {}),
+                nodeKey: nextNodeKey,
+                nodeId: readPhiCmsInstanceId(next.nodeId),
+                nodeKind: next.nodeKind,
+                regionType: typeof next.regionType === "number" ? next.regionType : null,
+                regionKey: typeof next.regionKey === "string" ? next.regionKey : null,
+                selectedLayoutAnchor: typeof next.selectedLayoutAnchor === "string"
+                    ? next.selectedLayoutAnchor
+                    : null,
+                openWiring: next.openWiring === true,
+            });
+            return;
+        }
+        if (signal.channel === "builderMode" && signal.action === "change") {
+            const rawValue = signal.value;
+            if (rawValue === "editor") {
+                enterEditor();
+                return;
+            }
+            if (rawValue === "preview") {
+                void enterPreview().catch((error) => {
+                    dispatchSignal({
+                        scope: "area",
+                        channel: "builderMode",
+                        action: "change",
+                        value: state.builderMode,
+                        valueType: "string",
+                        sender: createPhiBuilderControllerAddress(),
+                        receiver: "broadcast",
+                        correlationId: signal.correlationId,
+                        timestamp: Date.now(),
+                    });
+                    showMessage({ level: "error", content: error instanceof Error ? error.message : "Preview snapshot failed." }, { correlationId: signal.correlationId });
+                });
+            }
+            return;
+        }
+        /*
+         * Where the target Area's root goes.
+         *
+         * The Select emits one string: a sentinel for the two answers that are not a Page, or a Page
+         * reference. It lands in the structure draft, which states `config.shell` whole on every save.
+         */
+        if (signal.scope === "area" &&
+            signal.channel === "rootRoute" &&
+            signal.action === "change" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            if (typeof signal.value !== "string") {
+                return;
+            }
+            const currentRootRoute = readPhiBuilderEffectiveAreaRootRoute(state, state.area);
+            /*
+             * Recorded like every other edit in this workspace, and for the same reason.
+             *
+             * What the Shell says about itself is not in its Region tree, so it used to pass the history by
+             * -- the front door was the one thing in `/shells` that could be changed and not taken back.
+             * The scope is the structure workspace because that is the only surface these Selects appear on.
+             */
+            setPhiDeveloperBuilderAreaRootRoute(state.area, signal.value === PHI_BUILDER_AREA_ROOT_ROUTE_AUTOMATIC
+                ? null
+                : signal.value === PHI_BUILDER_AREA_ROOT_ROUTE_LANDING
+                    // Switching back to a landing keeps the applicant that was chosen before, if there was
+                    // one: the two Selects answer one question between them, and the second one's answer is
+                    // not something the first one just unsaid.
+                    ? { mode: "landing", ...(currentRootRoute?.mode === "landing" && currentRootRoute.target
+                            ? { target: currentRootRoute.target }
+                            : {}) }
+                    : { mode: "redirect", target: signal.value }, {
+                historyContext: createPhiBuilderHistoryContext({ workspace: "structure", area: state.area }),
+                historyLabel: "Change root route",
+            });
+            return;
+        }
+        /*
+         * Which landing stands at the root, among those offered.
+         *
+         * Only reachable while the Area is set to a landing, because that is when the Select is enabled.
+         * Clearing it is an answer of its own -- a landing without an applicant, whose tree the Site
+         * authors itself -- so an empty value stores the mode without a target rather than nothing.
+         */
+        if (signal.scope === "area" &&
+            signal.channel === "landingPage" &&
+            signal.action === "change" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            const target = typeof signal.value === "string" &&
+                signal.value.length > 0 &&
+                signal.value !== PHI_BUILDER_AREA_LANDING_PAGE_EMPTY
+                ? signal.value
+                : null;
+            setPhiDeveloperBuilderAreaRootRoute(state.area, target ? { mode: "landing", target } : { mode: "landing" }, {
+                historyContext: createPhiBuilderHistoryContext({ workspace: "structure", area: state.area }),
+                historyLabel: "Change landing page",
+            });
+            return;
+        }
+        /*
+         * Whether the Area may be found, and whether its Pages are listed.
+         *
+         * Two switches, one sentence each, stored key by key: the answers are given one at a time and
+         * the one nobody touched has to keep saying what it said. Only Public can reach here at all,
+         * because only there are the switches enabled.
+         */
+        if (signal.scope === "area" &&
+            (signal.channel === "seoIndex" || signal.channel === "seoSitemap") &&
+            signal.action === "change" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            if (typeof signal.value !== "boolean") {
+                return;
+            }
+            setPhiDeveloperBuilderAreaMeta(state.area, signal.channel === "seoIndex" ? { index: signal.value } : { sitemap: signal.value }, {
+                historyContext: createPhiBuilderHistoryContext({ workspace: "structure", area: state.area }),
+                historyLabel: "Change area SEO",
+            });
+            return;
+        }
+        /*
+         * What the Area puts in the title of its Pages.
+         *
+         * Stored key by key like the switches above, and for the same reason. Empty is stored as empty
+         * rather than removed: the Area was asked and answered "the Site's name", which is what the
+         * reader resolves an absent template to anyway -- but an Area that has never been asked must
+         * stay distinguishable from one that was, or the next unrelated save would write a guess.
+         */
+        if (signal.scope === "area" &&
+            (signal.channel === "titleTemplate" || signal.channel === "defaultTitle") &&
+            signal.action === "change" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            if (typeof signal.value !== "string") {
+                return;
+            }
+            setPhiDeveloperBuilderAreaMeta(state.area, signal.channel === "titleTemplate"
+                ? { titleTemplate: signal.value }
+                : { defaultTitle: signal.value }, {
+                historyContext: createPhiBuilderHistoryContext({ workspace: "structure", area: state.area }),
+                historyLabel: "Change area title",
+            });
+            return;
+        }
+        /* The dialog those switches stand in, opened from the workspace header and closed from its footer. */
+        if (signal.scope === "area" &&
+            signal.channel === "areaSettings" &&
+            signal.action === "activate" &&
+            signal.valueType === "string" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            const open = signal.value === "open";
+            dispatchAreaSettingsDialog(open, signal.correlationId);
+            if (open) {
+                publishAreaSettingsState(signal.correlationId);
+            }
+            return;
+        }
+        if (signal.scope === "area" &&
+            signal.channel === "layout" &&
+            signal.action === "change" &&
+            signal.receiver === createPhiBuilderControllerAddress()) {
+            if (typeof signal.value !== "boolean") {
+                return;
+            }
+            const nextMode = signal.value ? "fullHeight" : "content";
+            handledSiderLayoutRef.current = {
+                draftKey: getPhiBuilderRegionDraftKey(state.area, "sider_left", state.pageKey),
+                fullHeight: signal.value,
+            };
+            applyPhiDeveloperBuilderSiderLeftMode(state.area, state.pageKey, nextMode);
+            dispatchSignal({
+                scope: "area",
+                channel: "layout",
+                action: "change",
+                value: signal.value,
+                valueType: "boolean",
+                sender: createPhiBuilderControllerAddress(),
+                receiver: "broadcast",
+                correlationId: signal.correlationId,
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if ((signal.channel === "region" || signal.channel === "selection") &&
+            signal.action === "change") {
+            const rawValue = signal.value;
+            const next = rawValue && typeof rawValue === "object"
+                ? rawValue
+                : null;
+            if (!next || typeof next.regionKey !== "string" || typeof next.nodeKind !== "string") {
+                return;
+            }
+            const nextRegionKey = next.regionKey;
+            const nextNodeKind = next.nodeKind === "slot" ? "slot" : "region";
+            const nextNodeKey = typeof next.nodeKey === "string"
+                ? next.nodeKey
+                : `${nextNodeKind}:${nextRegionKey}`;
+            builderWorkspaceStore.patch(defaultArea, (current) => ({
+                ...current,
+                nodeKey: nextNodeKey,
+                nodeId: null,
+                nodeKind: nextNodeKind,
+                selectedRegionType: typeof next.regionType === "number"
+                    ? next.regionType
+                    : current.selectedRegionType,
+                selectedRegionKey: nextRegionKey,
+                selectedRootRegionKey: null,
+                inspectorOpen: nextNodeKind === "region",
+                sidebarKey: "structure",
+                pagesOpen: false,
+            }));
+            return;
+        }
+        if (signal.channel === "command" && signal.action === "activate" && signal.value === "pagesOpen") {
+            builderWorkspaceStore.patch(defaultArea, (current) => ({ ...current, pagesOpen: true }));
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() && signal.channel === "effects") {
+            if (signal.action === "change" && signal.valueType === "none") {
+                effectsWorkflowCorrelationRef.current = signal.correlationId;
+                effectsFormSubmissionRef.current = null;
+            }
+            else if (signal.action === "activate" && signal.valueType === "string" && signal.value === "save") {
+                const correlationId = effectsWorkflowCorrelationRef.current ?? signal.correlationId;
+                effectsFormSubmissionRef.current = { correlationId, values: {} };
+                dispatchSignal({
+                    scope: "area",
+                    channel: "effectsSubmitting",
+                    action: "change",
+                    value: true,
+                    valueType: "boolean",
+                    correlationId,
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiSignalSubcontrolAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsCommands, "save"),
+                    timestamp: Date.now(),
+                });
+                for (const section of PHI_BUILDER_EFFECTS_SECTIONS) {
+                    const widgetId = PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS[section];
+                    dispatchSignal({
+                        scope: "area",
+                        channel: "submit",
+                        action: "activate",
+                        value: null,
+                        valueType: "none",
+                        correlationId,
+                        sender: createPhiBuilderControllerAddress(),
+                        receiver: createPhiSignalAddress("cms", widgetId),
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            else if ((signal.action === "activate" && signal.valueType === "string" && signal.value === "cancel") ||
+                (signal.action === "close" &&
+                    (signal.valueType === "none" ||
+                        (signal.valueType === "json" &&
+                            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.overlayCloseRequest)))) {
+                const correlationId = effectsWorkflowCorrelationRef.current ?? signal.correlationId;
+                for (const section of PHI_BUILDER_EFFECTS_SECTIONS) {
+                    const widgetId = PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS[section];
+                    dispatchSignal({
+                        scope: "area",
+                        channel: "reset",
+                        action: "activate",
+                        value: null,
+                        valueType: "none",
+                        correlationId,
+                        sender: createPhiBuilderControllerAddress(),
+                        receiver: createPhiSignalAddress("cms", widgetId),
+                        timestamp: Date.now(),
+                    });
+                }
+                dispatchSignal({
+                    scope: "area",
+                    channel: "dialog",
+                    action: "close",
+                    value: null,
+                    valueType: "none",
+                    correlationId,
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_OVERLAY_IDS.effectsEditor),
+                    timestamp: Date.now(),
+                });
+                dispatchSignal({
+                    scope: "area",
+                    channel: "effectsCancel",
+                    action: "close",
+                    value: null,
+                    valueType: "none",
+                    correlationId,
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: "broadcast",
+                    timestamp: Date.now(),
+                });
+                effectsWorkflowCorrelationRef.current = null;
+                effectsFormSubmissionRef.current = null;
+                dispatchSignal({
+                    scope: "area",
+                    channel: "effectsSubmitting",
+                    action: "change",
+                    value: false,
+                    valueType: "boolean",
+                    correlationId,
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiSignalSubcontrolAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsCommands, "save"),
+                    timestamp: Date.now(),
+                });
+            }
+            return;
+        }
+        /*
+         * Signal wiring. The Form publishes its values to its own Form controller address as the author
+         * edits, which is what keeps the four cascading selects answerable; Apply routes through the
+         * Form's own submit so its validation runs before a route is written.
+         */
+        if (signal.receiver === PHI_BUILDER_SIGNAL_WIRING_FORM_CONTROLLER_ADDRESS &&
+            signal.action === "change" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.formValues) {
+            const submitted = readPhiRuntimeFormValuesSignalValue(signal.value);
+            if (submitted)
+                patchPhiBuilderSignalWiringSession(defaultArea, submitted.values);
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() &&
+            signal.channel === "signalWiringRoutes" &&
+            signal.action === "activate" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.tableAction) {
+            const tableAction = readPhiTableActionSignalValue(signal.value);
+            if (tableAction?.actionKey !== "delete" || typeof tableAction.rowIdentity !== "string") {
+                return;
+            }
+            const routes = resolvePhiBuilderSignalWiringRoutesWithout(defaultArea, tableAction.rowIdentity);
+            if (!routes)
+                return;
+            const routeState = getPhiDeveloperBuilderStateSnapshot(defaultArea);
+            runPhiDeveloperBuilderInspectorAction(defaultArea, routeState.nodeKind === "layout"
+                ? { kind: "patchSelectedLayoutConfig", key: "signalRoutes", value: routes }
+                : { kind: "patchSelectedWidgetConfig", patch: { signalRoutes: routes } });
+            dispatchSignal({
+                scope: "area",
+                channel: "reload",
+                action: "activate",
+                value: null,
+                valueType: "none",
+                correlationId: signal.correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.signalWiringRoutes),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() &&
+            signal.channel === "signalWiring") {
+            if (signal.action === "activate" && signal.valueType === "string" && signal.value === "apply") {
+                dispatchSignal({
+                    scope: "area",
+                    channel: "submit",
+                    action: "activate",
+                    value: null,
+                    valueType: "none",
+                    correlationId: signal.correlationId,
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.signalWiringForm),
+                    timestamp: Date.now(),
+                });
+                return;
+            }
+            /*
+             * Cancel, the close button, and a click on the mask all end here. The overlay runs with
+             * `closeMode: "request"`, so it does not close itself -- it asks, and closing is the answer. Both
+             * the session and the Form are cleared, or the next wiring session would open on the last one's
+             * half-finished selection.
+             */
+            const isCloseRequest = (signal.action === "activate" && signal.valueType === "string" && signal.value === "cancel") ||
+                (signal.action === "close" &&
+                    (signal.valueType === "none" ||
+                        (signal.valueType === "json" &&
+                            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.overlayCloseRequest)));
+            if (!isCloseRequest) {
+                return;
+            }
+            resetPhiBuilderSignalWiringSession(defaultArea);
+            dispatchSignal({
+                scope: "area",
+                channel: "reset",
+                action: "activate",
+                value: null,
+                valueType: "none",
+                correlationId: signal.correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.signalWiringForm),
+                timestamp: Date.now(),
+            });
+            dispatchSignal({
+                scope: "area",
+                channel: "dialog",
+                action: "close",
+                value: null,
+                valueType: "none",
+                correlationId: signal.correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_OVERLAY_IDS.signalWiring),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() &&
+            signal.channel === "signalWiringForm" &&
+            signal.action === "change" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.formValues) {
+            const submitted = readPhiRuntimeFormValuesSignalValue(signal.value);
+            if (!submitted)
+                return;
+            patchPhiBuilderSignalWiringSession(defaultArea, submitted.values);
+            const result = resolvePhiBuilderSignalWiringRoutes(defaultArea);
+            if (result.kind !== "applied")
+                return;
+            const wiringState = getPhiDeveloperBuilderStateSnapshot(defaultArea);
+            runPhiDeveloperBuilderInspectorAction(defaultArea, wiringState.nodeKind === "layout"
+                ? { kind: "patchSelectedLayoutConfig", key: "signalRoutes", value: result.routes }
+                : { kind: "patchSelectedWidgetConfig", patch: { signalRoutes: result.routes } });
+            resetPhiBuilderSignalWiringSession(defaultArea);
+            dispatchSignal({
+                scope: "area",
+                channel: "dialog",
+                action: "close",
+                value: null,
+                valueType: "none",
+                correlationId: signal.correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_OVERLAY_IDS.signalWiring),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() &&
+            signal.channel.startsWith("effectsFormValidation:") &&
+            signal.action === "change" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.formValidity) {
+            const pending = effectsFormSubmissionRef.current;
+            if (!pending || signal.correlationId !== pending.correlationId)
+                return;
+            effectsFormSubmissionRef.current = null;
+            dispatchSignal({
+                scope: "area",
+                channel: "effectsSubmitting",
+                action: "change",
+                value: false,
+                valueType: "boolean",
+                correlationId: pending.correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalSubcontrolAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsCommands, "save"),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() &&
+            signal.channel === "effectsVisibility" &&
+            signal.action === "change" &&
+            signal.value === false &&
+            effectsWorkflowCorrelationRef.current) {
+            const correlationId = effectsWorkflowCorrelationRef.current;
+            for (const section of PHI_BUILDER_EFFECTS_SECTIONS) {
+                const widgetId = PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS[section];
+                dispatchSignal({
+                    scope: "area",
+                    channel: "reset",
+                    action: "activate",
+                    value: null,
+                    valueType: "none",
+                    correlationId,
+                    sender: createPhiBuilderControllerAddress(),
+                    receiver: createPhiSignalAddress("cms", widgetId),
+                    timestamp: Date.now(),
+                });
+            }
+            dispatchSignal({
+                scope: "area",
+                channel: "effectsCancel",
+                action: "close",
+                value: null,
+                valueType: "none",
+                correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: "broadcast",
+                timestamp: Date.now(),
+            });
+            effectsWorkflowCorrelationRef.current = null;
+            effectsFormSubmissionRef.current = null;
+            dispatchSignal({
+                scope: "area",
+                channel: "effectsSubmitting",
+                action: "change",
+                value: false,
+                valueType: "boolean",
+                correlationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalSubcontrolAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsCommands, "save"),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.receiver === createPhiBuilderControllerAddress() &&
+            signal.channel.startsWith("effectsForm:") &&
+            signal.action === "change" &&
+            signal.valueSchema === PHI_SIGNAL_VALUE_SCHEMAS.formValues) {
+            const section = signal.channel.slice("effectsForm:".length);
+            if (section !== "appearance" && section !== "transitions" && section !== "viewport")
+                return;
+            const pending = effectsFormSubmissionRef.current;
+            const submitted = readPhiRuntimeFormValuesSignalValue(signal.value);
+            if (!pending || !submitted || signal.correlationId !== pending.correlationId)
+                return;
+            pending.values[section] = submitted.values;
+            if (!pending.values.appearance || !pending.values.transitions || !pending.values.viewport)
+                return;
+            const effectsCorrelationId = pending.correlationId;
+            const effects = mergePhiBuilderEffectsFormValues({
+                appearance: pending.values.appearance,
+                transitions: pending.values.transitions,
+                viewport: pending.values.viewport,
+            });
+            dispatchSignal({
+                scope: "area",
+                channel: "effectsCommit",
+                action: "change",
+                value: { values: { effects } },
+                valueType: "json",
+                valueSchema: PHI_SIGNAL_VALUE_SCHEMAS.formValues,
+                correlationId: effectsCorrelationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: "broadcast",
+                timestamp: Date.now(),
+            });
+            dispatchSignal({
+                scope: "area",
+                channel: "dialog",
+                action: "close",
+                value: null,
+                valueType: "none",
+                correlationId: effectsCorrelationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalAddress("cms", PHI_BUILDER_INSPECTOR_OVERLAY_IDS.effectsEditor),
+                timestamp: Date.now(),
+            });
+            effectsWorkflowCorrelationRef.current = null;
+            effectsFormSubmissionRef.current = null;
+            dispatchSignal({
+                scope: "area",
+                channel: "effectsSubmitting",
+                action: "change",
+                value: false,
+                valueType: "boolean",
+                correlationId: effectsCorrelationId,
+                sender: createPhiBuilderControllerAddress(),
+                receiver: createPhiSignalSubcontrolAddress("cms", PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsCommands, "save"),
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        if (signal.channel === "inspectorVisibility" && signal.action === "change" && typeof signal.value === "boolean") {
+            builderWorkspaceStore.patch(defaultArea, (current) => ({ ...current, inspectorOpen: signal.value }));
+            return;
+        }
+        if (signal.channel === "inspector" && signal.action === "change") {
+            if (signal.receiver !== createPhiBuilderControllerAddress() ||
+                signal.valueType !== "json" ||
+                signal.valueSchema !== PHI_SIGNAL_VALUE_SCHEMAS.builderInspector) {
+                return;
+            }
+            const action = readPhiBuilderInspectorAction(signal.value);
+            if (action) {
+                runPhiDeveloperBuilderInspectorAction(defaultArea, action);
+            }
+            return;
+        }
+        return;
+    }, undefined, 
+    /*
+     * The address this listener answers for.
+     *
+     * It was answered anyway, but by accident: the Page controller beside it names the same address in
+     * its own filter, and that one count carried every signal the Builder sends here. Saying it where
+     * the listener is means the Builder does not go silent the day that other listener changes.
+     */
+    createPhiBuilderControllerAddress());
+    useEffect(() => {
+        dispatchSignal({
+            scope: "area",
+            channel: "areaSelection",
+            action: "change",
+            value: state.area,
+            valueType: "string",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: "broadcast",
+            timestamp: Date.now(),
+        });
+    }, [dispatchSignal, state.area]);
+    /*
+     * The header Area selector is disabled at rest and armed only by pages that edit one Area at a
+     * time (`isPhiAreaScopedBuilderPage` holds the opt-in list). Steering it from here rather than
+     * baking the state into the Shell tree keeps a DB-overridden Builder Shell honest: whatever the
+     * stored tree says, the live page decides. It is stated once and held by the bus until the
+     * selector exists, so a late-mounting Shell hears it without anybody waiting for it here.
+     */
+    const areaSelectorAddress = useMemo(() => createPhiSignalAddress("cms", createPhiPresetCmsInstanceId({
+        domain: "area",
+        ownerModuleId: PHI_BUILDER_RUNTIME_MODULE_ID,
+        presetKey: "builder-area-preset",
+        nodeKey: "widgetBuilderAreaSelector",
+    })), []);
+    const areaSelectorArmed = isPhiAreaScopedBuilderPage(resolvePhiDeveloperBuilderRouteScope(pathname)?.pageKey ?? "root");
+    useEffect(() => {
+        dispatchSignal({
+            scope: "area",
+            channel: "enabled",
+            action: "change",
+            value: areaSelectorArmed,
+            valueType: "boolean",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: areaSelectorAddress,
+            timestamp: Date.now(),
+        });
+    }, [areaSelectorArmed, areaSelectorAddress, dispatchSignal]);
+    // The debug switch rests disabled the same way, armed only where a canvas is drawn.
+    const debugSwitchAddress = useMemo(() => createPhiSignalAddress("cms", createPhiPresetCmsInstanceId({
+        domain: "area",
+        ownerModuleId: PHI_BUILDER_RUNTIME_MODULE_ID,
+        presetKey: "builder-area-preset",
+        nodeKey: "widgetHeaderMainDebugSwitch",
+    })), []);
+    const debugSwitchArmed = isPhiDebugScaffoldBuilderPage(resolvePhiDeveloperBuilderRouteScope(pathname)?.pageKey ?? "root");
+    useEffect(() => {
+        dispatchSignal({
+            scope: "area",
+            channel: "enabled",
+            action: "change",
+            value: debugSwitchArmed,
+            valueType: "boolean",
+            sender: createPhiBuilderControllerAddress(),
+            receiver: debugSwitchAddress,
+            timestamp: Date.now(),
+        });
+    }, [debugSwitchArmed, debugSwitchAddress, dispatchSignal]);
+    return pageMetaDialog;
+}
+export function PhiDeveloperBuilderWorkspaceController({ defaultArea = "public", shellPresetDraftsByArea = {}, runtimeModuleDefinitions = [], runtimeModuleIdsByArea = {}, modulePresetPagesByArea = EMPTY_MODULE_PRESET_PAGES_BY_AREA, areaPresetSourcesByArea = {}, navigationSurfacesByArea = {}, unresolvedModuleIdsByArea = EMPTY_RUNTIME_MODULE_IDS_BY_AREA, publicRouteClaims = EMPTY_PUBLIC_ROUTE_CLAIMS, publicRoutePaths = EMPTY_PUBLIC_ROUTE_PATHS, areaRootRoutesByArea = EMPTY_AREA_ROOT_ROUTES, areaMetaByArea = EMPTY_AREA_META, pageMetaLabels = PHI_BUILDER_PAGE_META_DEFAULT_PRESENTATION_LABELS, }) {
+    const controller = usePhiDeveloperBuilderWorkspaceController(defaultArea, {
+        shellPresetDraftsByArea,
+        runtimeModuleDefinitions,
+        runtimeModuleIdsByArea,
+        modulePresetPagesByArea,
+        areaPresetSourcesByArea,
+        navigationSurfacesByArea,
+        unresolvedModuleIdsByArea,
+        publicRouteClaims,
+        publicRoutePaths,
+        areaRootRoutesByArea,
+        areaMetaByArea,
+        pageMetaLabels,
+    });
+    return controller;
+}