@phis/ui 0.4.2 → 0.4.3

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

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

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

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

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

@@ -296,13 +296,13 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
     const activeModules = usePhiRuntimeModuleState();
     const authoringCanvas = usePhiBuilderAuthoringCanvas();
     const builderState = {
-        area: usePhiDeveloperBuilderStateValue("public", (state) => state.area),
-        pageKey: usePhiDeveloperBuilderStateValue("public", (state) => state.pageKey),
-        builderMode: usePhiDeveloperBuilderStateValue("public", (state) => state.builderMode),
-        debugScaffold: usePhiDeveloperBuilderStateValue("public", (state) => state.debugScaffold),
-        pickerWidgetCategoryFilters: usePhiDeveloperBuilderStateValue("public", (state) => state.pickerWidgetCategoryFilters),
-        selectedLayoutAnchor: usePhiDeveloperBuilderStateValue("public", (state) => state.selectedRootRegionKey === config.regionKey ? state.selectedLayoutAnchor : null),
-        regionSelected: usePhiDeveloperBuilderStateValue("public", (state) => state.nodeKind === "region" && state.selectedRegionKey === config.regionKey),
+        area: usePhiDeveloperBuilderStateValue((state) => state.area),
+        pageKey: usePhiDeveloperBuilderStateValue((state) => state.pageKey),
+        builderMode: usePhiDeveloperBuilderStateValue((state) => state.builderMode),
+        debugScaffold: usePhiDeveloperBuilderStateValue((state) => state.debugScaffold),
+        pickerWidgetCategoryFilters: usePhiDeveloperBuilderStateValue((state) => state.pickerWidgetCategoryFilters),
+        selectedLayoutAnchor: usePhiDeveloperBuilderStateValue((state) => state.selectedRootRegionKey === config.regionKey ? state.selectedLayoutAnchor : null),
+        regionSelected: usePhiDeveloperBuilderStateValue((state) => state.nodeKind === "region" && state.selectedRegionKey === config.regionKey),
     };
     const builderModuleMetas = usePhiBuilderModuleMetas(builderState.area);
     const layoutMetasByType = useMemo(() => buildPhiBuilderContainerMetaMap(builderModuleMetas.plugins), [builderModuleMetas.plugins]);
@@ -424,9 +424,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
         if (!hasRootNode || isPreviewMode || !rootNodeKind) {
             return;
         }
-        selectPhiDeveloperBuilderNode("public", {
-            area: builderState.area,
-            pageKey: builderState.pageKey,
+        selectPhiDeveloperBuilderNode({
             regionKey: config.regionKey,
             nodeId: options?.nodeId ?? rootNodeId,
             nodeKey: options?.nodeKey ?? rootNodeTypeKey,
@@ -1026,7 +1024,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
     }, [builderMode, isPicking]);
     useEffect(() => {
         if (!Array.isArray(builderState.pickerWidgetCategoryFilters)) {
-            patchPhiDeveloperBuilderState("public", { pickerWidgetCategoryFilters: [] });
+            patchPhiDeveloperBuilderState({ pickerWidgetCategoryFilters: [] });
         }
     }, [builderState.pickerWidgetCategoryFilters]);
     useEffect(() => {
@@ -1074,9 +1072,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
         if (!config.allowSelect || isPreviewMode) {
             return;
         }
-        selectPhiDeveloperBuilderNode("public", {
-            area: builderState.area,
-            pageKey: builderState.pageKey,
+        selectPhiDeveloperBuilderNode({
             nodeKind: "region",
             nodeKey: `region:${config.regionKey}`,
             regionKey: config.regionKey,
@@ -1113,9 +1109,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
         setSlotPickerContext(nextSlotPickerContext);
         setPickSection(nextDefaultPickSection);
         setIsPicking(true);
-        selectPhiDeveloperBuilderNode("public", {
-            area: builderState.area,
-            pageKey: builderState.pageKey,
+        selectPhiDeveloperBuilderNode({
             regionKey: config.regionKey,
             nodeKey: `slot:${config.regionKey}`,
             nodeKind: "slot",
@@ -1150,7 +1144,7 @@ export function PhiStructureRegionScaffold({ config, serverPreview, structureDra
                 if (!nextOpen && isActiveTarget)
                     closePicker();
             }, onSectionChange: setPickSection, onPackageFiltersChange: setPickPackageFilters, onWidgetCategoryFiltersChange: (filters) => {
-                patchPhiDeveloperBuilderState("public", { pickerWidgetCategoryFilters: filters });
+                patchPhiDeveloperBuilderState({ pickerWidgetCategoryFilters: filters });
             }, onChange: (item) => void insertPickedItem(item) }, key));
     }
     /*

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

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

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

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

package/plugins/runtime-modules/client-manifests/common.js

@@ -11,7 +11,7 @@ import { PHI_ASSET_RUNTIME_MODULE_ID } from "../asset/ids";
 import { PHI_MEDIA_LIBRARY_ITEM_RENDERER_KEY } from "../../../constants/media-library-provider-keys";
 import { PHI_DASHBOARD_CARD_ITEM_RENDERER_KEY } from "../../../constants/dashboard-card-provider-keys";
 import { createPhiRuntimeModuleCalendarAdapterClientManifest } from "../../../components/runtime/runtime-module-calendar-adapter-client-manifest";
-import { PHI_CORE_CALENDAR_ADAPTER_CLIENT_DEFINITIONS } from "../client-calendar-adapters/core";
+import { PHI_CORE_CALENDAR_ADAPTER_CLIENT_DEFINITIONS } from "../core/client-calendar-adapters";
 import { PhiLazyAssetRuntimeControllerClient } from "../asset/client";
 import { createPhiRuntimeModuleUiProviderClientManifest, } from "../../../components/runtime/runtime-module-ui-provider-client-manifest";
 import { PHI_AUTH_RUNTIME_MODULE_ID } from "../auth/ids";

package/plugins/runtime-modules/{runtime-calendar-adapters.js → core/calendar-adapters.js}

@@ -1,5 +1,5 @@
-import { PHI_GREGORY_CALENDAR_ADAPTER_KEY } from "../../types/calendar-keys";
-import { PHI_CORE_RUNTIME_MODULE_ID } from "./core/ids";
+import { PHI_GREGORY_CALENDAR_ADAPTER_KEY } from "../../../types/calendar-keys";
+import { PHI_CORE_RUNTIME_MODULE_ID } from "./ids";
 export const PHI_CORE_CALENDAR_ADAPTER_DESCRIPTORS = [{
         key: PHI_GREGORY_CALENDAR_ADAPTER_KEY,
         ownerModuleId: PHI_CORE_RUNTIME_MODULE_ID,

package/plugins/runtime-modules/{client-calendar-adapters/core.js → core/client-calendar-adapters.js}

@@ -1,6 +1,6 @@
 "use client";
 import { PHI_GREGORY_CALENDAR_ADAPTER_KEY } from "../../../types/calendar-keys";
-import { PHI_CORE_RUNTIME_MODULE_ID } from "../core/ids";
+import { PHI_CORE_RUNTIME_MODULE_ID } from "./ids";
 export const PHI_CORE_CALENDAR_ADAPTER_CLIENT_DEFINITIONS = [{
         key: PHI_GREGORY_CALENDAR_ADAPTER_KEY,
         ownerModuleId: PHI_CORE_RUNTIME_MODULE_ID,

package/plugins/runtime-modules/core/content-entries/table.js

@@ -53,7 +53,7 @@ async function loadEntries(kind, { query, signal }) {
     }));
     return {
         rows,
-        total: readNumber(result?.total) ?? rows.length,
+        total: readNumber(result?.total),
         page: readNumber(result?.page) ?? 1,
         pageSize: readNumber(result?.pageSize) ?? (rows.length || 25),
         /*

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

@@ -56,6 +56,7 @@ export declare const PHI_CORE_RUNTIME_DATA_PROVIDER_DESCRIPTORS: ({
             search: false;
             sorting: "none";
             pagination: "offset";
+            total: true;
             filterFields: string[];
         };
         actions: ({
@@ -115,6 +116,7 @@ export declare const PHI_CORE_RUNTIME_DATA_PROVIDER_DESCRIPTORS: ({
             search: true;
             sorting: "multiple";
             pagination: "offset";
+            total: true;
         };
     }[];
     settingsFields?: undefined;
@@ -205,6 +207,7 @@ export declare const PHI_CORE_RUNTIME_DATA_PROVIDER_DESCRIPTORS: ({
             filterFields: string[];
             sorting: "none";
             pagination: "offset";
+            total: true;
             facets: string[];
         };
         recordRead: true;

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

@@ -35,7 +35,7 @@ export const PHI_CORE_RUNTIME_DATA_PROVIDER_DESCRIPTORS = [
                 description: "Neutral package-owned baseline for a provider-bound table.",
                 rowIdentityPath: "id",
                 fields: [{ key: "id", title: "ID", type: "string", required: true }],
-                query: { search: true, sorting: "multiple", pagination: "offset" },
+                query: { search: true, sorting: "multiple", pagination: "offset", total: true },
             }],
     },
     ...PHI_CORE_MESSAGING_DATA_PROVIDER_DESCRIPTORS,
@@ -121,6 +121,7 @@ export const PHI_CORE_RUNTIME_DATA_PROVIDER_DESCRIPTORS = [
                 filterFields: ["status"],
                 sorting: "none",
                 pagination: "offset",
+                total: true,
                 facets: ["tags"],
             },
             recordRead: true,

package/plugins/runtime-modules/core/definition.d.ts

@@ -67,6 +67,7 @@ export declare const PHI_CORE_RUNTIME_MODULE_DEFINITION: {
                 search: false;
                 sorting: "none";
                 pagination: "offset";
+                total: true;
                 filterFields: string[];
             };
             actions: ({
@@ -126,6 +127,7 @@ export declare const PHI_CORE_RUNTIME_MODULE_DEFINITION: {
                 search: true;
                 sorting: "multiple";
                 pagination: "offset";
+                total: true;
             };
         }[];
         settingsFields?: undefined;
@@ -216,6 +218,7 @@ export declare const PHI_CORE_RUNTIME_MODULE_DEFINITION: {
                 filterFields: string[];
                 sorting: "none";
                 pagination: "offset";
+                total: true;
                 facets: string[];
             };
             recordRead: true;

package/plugins/runtime-modules/core/definition.js

@@ -6,7 +6,7 @@ import { PHI_CORE_RUNTIME_DATA_PROVIDER_DESCRIPTORS } from "./data-providers";
 import { PHI_CMS_AREA_KEYS } from "../../../constants/cms-areas";
 import { PHI_CORE_FORM_PROVIDER_DESCRIPTORS } from "./form-providers";
 import { PHI_CORE_SERVER_BINDING } from "../../../types/server-capabilities";
-import { PHI_CORE_CALENDAR_ADAPTER_DESCRIPTORS } from "../runtime-calendar-adapters";
+import { PHI_CORE_CALENDAR_ADAPTER_DESCRIPTORS } from "./calendar-adapters";
 export const PHI_CORE_RUNTIME_MODULE_DEFINITION = {
     ...PHI_CORE_RUNTIME_MODULE_IDENTITY,
     kind: "platform",

package/plugins/runtime-modules/core/messaging/data-providers.d.ts

@@ -77,6 +77,7 @@ export declare const PHI_CORE_MESSAGING_DATA_PROVIDER_DESCRIPTORS: {
             search: false;
             sorting: "none";
             pagination: "offset";
+            total: true;
             filterFields: string[];
         };
         actions: ({

package/plugins/runtime-modules/core/messaging/data-providers.js

@@ -81,6 +81,7 @@ export const PHI_CORE_MESSAGING_DATA_PROVIDER_DESCRIPTORS = [
                     search: false,
                     sorting: "none",
                     pagination: "offset",
+                    total: true,
                     /*
                      * The three the Core route takes, and no fourth.
                      *

package/plugins/runtime-modules/core/messaging/thread-inbox-table.js

@@ -61,7 +61,7 @@ async function queryThreadTable({ resourceKey, query, signal, }) {
     const rows = readPhiTableRows(payload?.rows).map(readThreadRow);
     return {
         rows,
-        total: typeof payload?.total === "number" ? payload.total : rows.length,
+        total: typeof payload?.total === "number" ? payload.total : undefined,
         page: typeof payload?.page === "number" ? payload.page : undefined,
         pageSize: typeof payload?.pageSize === "number" ? payload.pageSize : undefined,
         // Unread among everything the listing matches, for a footer beside the total.

package/plugins/runtime-modules/core/server.js

@@ -1,5 +1,5 @@
 import { PHI_CORE_RUNTIME_DATA_PROVIDER_KEYS } from "../../../constants/core-data-provider-keys";
-import { PHI_CORE_RUNTIME_MODULE_THEMES } from "../area-base-presets";
+import { PHI_CORE_RUNTIME_MODULE_THEMES } from "./themes";
 import { definePhiRuntimeModuleServerAreaContribution } from "../area-contributions";
 import { PHI_CORE_RUNTIME_MODULE_DEFINITION } from "./definition";
 import { PHI_RUNTIME_MODULE_LAYOUTS as PHI_CORE_LAYOUTS } from "./layouts";

package/plugins/runtime-modules/core/themes.d.ts

@@ -0,0 +1,44 @@
+export declare const PHI_CORE_RUNTIME_MODULE_THEMES: {
+    loadPreset: () => {
+        readonly key: "phis";
+        readonly version: 1;
+        readonly title: "Phis";
+        readonly description: "Warm orange brand color with a deep blue text base.";
+        readonly palette: {
+            readonly seed: {
+                readonly colorPrimary: "#E05A2A";
+                readonly colorInfo: "#7088BA";
+                readonly colorSuccess: "#4D8F6B";
+                readonly colorWarning: "#D99A2B";
+                readonly colorError: "#C94A3A";
+                readonly colorLink: "#7088BA";
+            };
+            readonly modes: {
+                readonly light: {
+                    readonly seed: {
+                        readonly colorTextBase: "#223A61";
+                        readonly colorBgBase: "#ffffff";
+                    };
+                    readonly overrides: {
+                        readonly colorFillQuaternary: "rgba(34, 58, 97, 0.03)";
+                    };
+                };
+                readonly dark: {
+                    readonly seed: {
+                        readonly colorTextBase: "#DCE7F8";
+                        readonly colorBgBase: "#050914";
+                    };
+                    readonly overrides: {
+                        readonly colorFillQuaternary: "rgba(220, 231, 248, 0.06)";
+                    };
+                };
+            };
+        };
+    };
+    description?: "Warm orange brand color with a deep blue text base." | undefined;
+    ownerModuleId: "@phis/ui/modules/core";
+    presetKey: string;
+    presetVersion: number;
+    themeKey: "phis";
+    title: "Phis";
+}[];