@phis/ui 0.2.0 → 0.3.0

package/plugins/runtime-modules/builder/area-settings-answer.js

@@ -0,0 +1,81 @@
+import { PHI_AREA_META_PUBLIC_DEFAULTS, } from "../../../helpers/cms-area-config";
+import { isPhiRecord } from "../../../helpers/is-record";
+import { builderWorkspaceStore, readPhiBuilderEffectiveAreaMeta, readPhiBuilderEffectiveAreaRootRoute, restorePhiDeveloperBuilderAreaMeta, setPhiDeveloperBuilderAreaRootRoute, } from "./developer-workspace-store";
+import { phiBuilderHistory } from "./history";
+/**
+ * What the Area settings dialog says about being found, as the whole answer the Area is left with.
+ *
+ * The dialog answers every field at once, so the answer replaces what stood rather than merging into
+ * it: a title the author emptied is a title taken away, and leaving the old key in place -- or writing
+ * `""` over it, as the merging setter did -- kept a value nobody chose. The switches are only read where
+ * the dialog asked them (`index`/`sitemap` given), so an Area that was never asked keeps its silence.
+ */
+export function resolvePhiBuilderAreaSettingsMeta(effective, answer) {
+    const next = { ...(effective ?? {}) };
+    delete next.titleTemplate;
+    delete next.defaultTitle;
+    const titleTemplate = typeof answer.titleTemplate === "string" ? answer.titleTemplate.trim() : "";
+    const defaultTitle = typeof answer.defaultTitle === "string" ? answer.defaultTitle.trim() : "";
+    if (titleTemplate)
+        next.titleTemplate = titleTemplate;
+    if (defaultTitle)
+        next.defaultTitle = defaultTitle;
+    if (answer.index !== undefined)
+        next.index = answer.index;
+    if (answer.sitemap !== undefined)
+        next.sitemap = answer.sitemap;
+    return next;
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (!isPhiRecord(value))
+        return value;
+    return Object.fromEntries(Object.keys(value)
+        .filter((key) => value[key] !== undefined)
+        .sort()
+        .map((key) => [key, canonicalize(value[key])]));
+}
+/**
+ * Whether two answers say the same thing, whatever order their keys were written in. The dialog builds
+ * its answer afresh, so comparing it by `JSON.stringify` against the stored one would call a reordered
+ * copy a change.
+ */
+function isSamePhiBuilderAreaAnswer(left, right) {
+    return JSON.stringify(canonicalize(left)) === JSON.stringify(canonicalize(right));
+}
+/**
+ * Writes what the Area settings dialog answered, as one step of the Area's history.
+ *
+ * One press of OK, one step: the root route and the SEO answers live in two places, but the author
+ * answered one dialog, and two entries made that press two undos -- the first of them leaving a state
+ * the author never saw. A part that says what already stood is neither written nor recorded, and an OK
+ * that changed nothing leaves no step at all, which would otherwise have marked an unchanged Area
+ * unsaved. `rootRoute` is `undefined` when the dialog did not ask it.
+ */
+export function applyPhiBuilderAreaSettingsAnswer({ area, historyContext, rootRoute, meta, }) {
+    const current = builderWorkspaceStore.getSnapshot("public");
+    const before = [];
+    const after = [];
+    if (rootRoute !== undefined && !isSamePhiBuilderAreaAnswer(readPhiBuilderEffectiveAreaRootRoute(current, area), rootRoute)) {
+        before.push({ kind: "areaRootRoute", area, rootRoute: current.areaRootRouteDrafts?.[area] });
+        after.push({ kind: "areaRootRoute", area, rootRoute });
+        setPhiDeveloperBuilderAreaRootRoute(area, rootRoute);
+    }
+    const effectiveMeta = readPhiBuilderEffectiveAreaMeta(current, area);
+    const nextMeta = resolvePhiBuilderAreaSettingsMeta(effectiveMeta, meta);
+    // An Area that was never asked about indexing means the defaults, so answering them is no change.
+    const defaults = area === "public" ? PHI_AREA_META_PUBLIC_DEFAULTS : {};
+    if (!isSamePhiBuilderAreaAnswer({ ...defaults, ...effectiveMeta }, { ...defaults, ...nextMeta })) {
+        before.push({ kind: "areaMeta", area, meta: current.areaMetaDrafts?.[area] });
+        after.push({ kind: "areaMeta", area, meta: nextMeta });
+        restorePhiDeveloperBuilderAreaMeta(area, nextMeta);
+    }
+    if (before.length > 0) {
+        phiBuilderHistory.record(historyContext, {
+            action: { key: "changeAreaSettings" },
+            before: { kind: "composite", parts: before },
+            after: { kind: "composite", parts: after },
+        });
+    }
+}

package/plugins/runtime-modules/builder/area-shell-presets.server.d.ts

@@ -1,9 +1,10 @@
 import "server-only";
+import type { PhiCmsTreeControllerSettings } from "../../../types/cms";
 import type { PhiRuntimeModuleCatalog, PhiRuntimeModuleId } from "../../../types";
 import type { PhiBlockRuntime } from "../../../types/widget-runtime";
 import { type PhiAreaLandingSelection, type PhiAreaRootRoute, type PhiAreaMeta, type PhiPublicRoutePathAssignment } from "../../../helpers/cms-area-config";
 import type { PhiDeveloperBuilderArea, PhiDeveloperBuilderRegionDraft } from "./developer-workspace-types";
-export type PhiBuilderAreaModulesConfig = {
+type PhiBuilderAreaModulesConfig = {
     moduleIds: PhiRuntimeModuleId[];
     /**
      * Stored ids this build cannot serve, kept so the Builder can show them.
@@ -15,8 +16,18 @@ export type PhiBuilderAreaModulesConfig = {
     unresolvedModuleIds: PhiRuntimeModuleId[];
     publicRoutePaths: PhiPublicRoutePathAssignment[];
 };
-/** What an Area says its `/` resolves to. */
-export declare function buildPhiBuilderAreaRootRoute(runtime: PhiBlockRuntime, area: PhiDeveloperBuilderArea, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<PhiAreaRootRoute | null>;
+/**
+ * The Areas whose structure has an open draft, from the one read every Builder view makes.
+ *
+ * For the Builder's Dashboard card (`cards.ts`). Outside a render the read is not shared with anything,
+ * and it is still one request for every Area.
+ */
+export declare function readPhiBuilderAreasWithOpenDraft(runtimeModuleCatalog: PhiRuntimeModuleCatalog, { siteKey, locale, apiBaseUrl, internalToken }: {
+    siteKey: string;
+    locale: string;
+    apiBaseUrl: string;
+    internalToken: string;
+}): Promise<PhiDeveloperBuilderArea[]>;
 /**
  * Which application for the Area root this Site answered, in the form the route table asks for.
  *
@@ -26,8 +37,6 @@ export declare function buildPhiBuilderAreaRootRoute(runtime: PhiBlockRuntime, a
  * rather than at the two call sites that compile a table.
  */
 export declare function buildPhiBuilderAreaLandingSelection(runtime: PhiBlockRuntime, area: PhiDeveloperBuilderArea, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<PhiAreaLandingSelection | null>;
-/** What an Area says about being found. */
-export declare function buildPhiBuilderAreaMeta(runtime: PhiBlockRuntime, area: PhiDeveloperBuilderArea, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<PhiAreaMeta | null>;
 export declare function resolvePhiBuilderCurrentStructureArea(runtime: PhiBlockRuntime): PhiDeveloperBuilderArea;
 export declare const buildPhiBuilderCurrentStructureShellDrafts: (runtime: PhiBlockRuntime, runtimeModuleCatalog: PhiRuntimeModuleCatalog) => Promise<{
     area: PhiDeveloperBuilderArea;
@@ -62,4 +71,11 @@ export declare function buildPhiBuilderPublicRoutePaths(runtime: PhiBlockRuntime
 export declare function buildPhiBuilderAreaRootRoutesByArea(runtime: PhiBlockRuntime, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<Record<string, PhiAreaRootRoute | null>>;
 /** What every Area states about being found, handed to the workspace beside the root routes. */
 export declare function buildPhiBuilderAreaMetaByArea(runtime: PhiBlockRuntime, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<Record<string, PhiAreaMeta | null>>;
+/**
+ * What every Area's Shell tells its Controllers, from the same chain the drafts come from: the open
+ * structure draft, else what is published, else the code-owned Shell. Carried into every structure save
+ * and every Module save baseline, which state the tree whole.
+ */
+export declare function buildPhiBuilderAreaControllerSettingsByArea(runtime: PhiBlockRuntime, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<Record<string, PhiCmsTreeControllerSettings>>;
 export declare function buildPhiBuilderStructureShellPresetDraftsByArea(runtime: PhiBlockRuntime, runtimeModuleCatalog: PhiRuntimeModuleCatalog): Promise<Record<PhiDeveloperBuilderArea, Record<string, PhiDeveloperBuilderRegionDraft>>>;
+export {};

package/plugins/runtime-modules/builder/area-shell-presets.server.js

@@ -1,8 +1,9 @@
 import "server-only";
+import { applyPhiPresetTreesCurrentContent } from "../../../server-helpers/cms-bound-content";
 import { cache } from "react";
 import { cookies } from "next/headers";
 import { PHI_BUILDER_AREA_KEYS } from "../../../constants/cms-areas";
-import { getCurrentSiteAreaDraft, getExactSiteArea } from "../../../gateway/site-area";
+import { getSiteAreaStructures } from "../../../gateway/site-area";
 import { readPhiRuntimeModuleIdsForArea } from "../../../plugins/runtime-modules/settings";
 import { readPhiAreaPresetRuntimeModuleIds, readPhiAreaPublicRoutePaths, readPhiAreaRootRoute, readPhiAreaMeta, resolvePhiAreaLandingSelection, } from "../../../helpers/cms-area-config";
 import { PHI_BUILDER_SHELL_REGION_KEYS } from "./region-keys";
@@ -11,21 +12,37 @@ import { resolvePhiBuilderAreaAsCmsArea } from "../../../constants/cms-areas";
 import { instantiatePhiCmsAreaShellPreset, resolvePhiCmsAreaShellPresetBinding, resolvePhiCmsDescriptorCatalog, } from "../../../plugins/runtime-modules/descriptor-compiler";
 import { PHI_BUILDER_AREA_SEARCH_PARAM, normalizePhiBuilderAreaSearchParam, } from "../../../helpers/cms-scope-search-params";
 import { readPhiServerApiCredentials } from "../../../helpers/phis-server-credentials";
-async function instantiateAreaShellPresetTree(runtime, area, runtimeModuleCatalog) {
-    const cmsArea = resolvePhiBuilderAreaAsCmsArea(area);
+/**
+ * Every Area's installed Shell as the Builder edits it: with the current content of every node somebody
+ * wrote content for. All Areas together and once per request, because the Builder holds the preset
+ * drafts of every Area on every view, and the content of their nodes is one read rather than one per
+ * Area (AUDIT-2026-10-13, PM12).
+ */
+const loadInstalledAreaShellPresetTrees = cache(async function loadInstalledAreaShellPresetTrees(runtime, runtimeModuleCatalog) {
     const catalog = resolvePhiCmsDescriptorCatalog(runtimeModuleCatalog);
-    const binding = resolvePhiCmsAreaShellPresetBinding(catalog, cmsArea);
-    if (!binding) {
-        return null;
-    }
-    const path = resolveStructureAreaPath(area);
-    return instantiatePhiCmsAreaShellPreset({
-        binding,
-        catalog,
-        siteId: runtime.site.id,
-        path,
-        runtime,
+    const installed = (await Promise.all(PHI_BUILDER_AREA_KEYS.map(async (area) => {
+        const binding = resolvePhiCmsAreaShellPresetBinding(catalog, resolvePhiBuilderAreaAsCmsArea(area));
+        if (!binding) {
+            return null;
+        }
+        const tree = await instantiatePhiCmsAreaShellPreset({
+            binding,
+            catalog,
+            siteId: runtime.site.id,
+            path: resolveStructureAreaPath(area),
+            runtime,
+        });
+        return [area, tree];
+    }))).filter((entry) => entry != null);
+    const trees = await applyPhiPresetTreesCurrentContent(installed.map(([, tree]) => tree), {
+        runtimeModuleCatalog,
+        siteKey: runtime.site.key,
+        cookieHeader: (await cookies()).toString(),
     });
+    return new Map(installed.map(([area], index) => [area, trees[index]]));
+});
+async function instantiateAreaShellPresetTree(runtime, area, runtimeModuleCatalog) {
+    return (await loadInstalledAreaShellPresetTrees(runtime, runtimeModuleCatalog)).get(area) ?? null;
 }
 function resolveAreaPresetSource(area, runtimeModuleCatalog) {
     const binding = resolvePhiCmsAreaShellPresetBinding(resolvePhiCmsDescriptorCatalog(runtimeModuleCatalog), resolvePhiBuilderAreaAsCmsArea(area));
@@ -74,38 +91,59 @@ function readRuntimeModulesConfigFromStructureTree(tree, area, runtimeModuleCata
         publicRoutePaths: readPhiAreaPublicRoutePaths(presetTree?.preset.config),
     };
 }
-const buildShellDraftsForArea = cache(async function buildShellDraftsForArea(runtime, siteKey, locale, apiBaseUrl, internalToken, area, runtimeModuleCatalog) {
-    const path = resolveStructureAreaPath(area);
-    const sourcePreset = resolveAreaPresetSource(area, runtimeModuleCatalog);
+/**
+ * What the Site stores about every Area's Shell: per Area the open structure draft, else what is
+ * published, else nothing. One request for all of them, once per request.
+ *
+ * The Builder needs every Area on every view -- the Modules page edits their selections together, and
+ * the Area switch carries the next Area's selection -- and read them with a draft read and, where no
+ * draft was open, a published read per Area: eleven of a Builder view's seventeen Core calls
+ * (AUDIT-2026-10-13, PM3). Keyed by the values the request turns on and never by an object, and read
+ * whole, so the Shell drafts, the Area config and the Module selection all come from one revision. The
+ * cookie header is read inside, where it is one value per request anyway.
+ */
+const loadPhiBuilderAreaStructures = cache(async function loadPhiBuilderAreaStructures(siteKey, locale, apiBaseUrl, internalToken, runtimeModuleCatalog) {
+    const areas = PHI_BUILDER_AREA_KEYS.map((area) => ({ area, ...resolveAreaPresetSource(area, runtimeModuleCatalog) }));
     const cookieHeader = (await cookies()).toString();
-    const draftPreset = await getCurrentSiteAreaDraft({
+    // A failed read is not "never asked": answering with the preset default would let the Builder show and
+    // save it over what the Area actually stores.
+    const structures = await getSiteAreaStructures({
         apiBaseUrl,
         internalToken,
         siteKey,
-        area,
-        path,
         locale,
         cookieHeader,
-        sourcePreset,
+        areas: areas.map(({ area, ownerModuleId, presetKey }) => ({ area, ownerModuleId, presetKey })),
     }).catch((error) => {
-        throw new Error(`Failed to resolve builder structure draft for area "${area}" at "${path}".`, { cause: error });
+        throw new Error("Failed to resolve the builder structure of the Areas.", { cause: error });
     });
-    if (draftPreset?.preset) {
-        return buildPhiProjectedBuilderRegionDrafts(runtime, draftPreset.preset, area, null, PHI_BUILDER_SHELL_REGION_KEYS);
+    return new Map(structures.map((structure, index) => [areas[index].area, {
+            draft: structure.draft?.preset ?? null,
+            published: structure.draft ? null : structure.published?.preset ?? null,
+        }]));
+});
+/**
+ * The Areas whose structure has an open draft, from the one read every Builder view makes.
+ *
+ * For the Builder's Dashboard card (`cards.ts`). Outside a render the read is not shared with anything,
+ * and it is still one request for every Area.
+ */
+export async function readPhiBuilderAreasWithOpenDraft(runtimeModuleCatalog, { siteKey, locale, apiBaseUrl, internalToken }) {
+    const structures = await loadPhiBuilderAreaStructures(siteKey, locale, apiBaseUrl, internalToken, runtimeModuleCatalog);
+    return PHI_BUILDER_AREA_KEYS.filter((area) => structures.get(area)?.draft != null);
+}
+async function loadPhiBuilderAreaStructure(siteKey, locale, apiBaseUrl, internalToken, area, runtimeModuleCatalog) {
+    const structure = (await loadPhiBuilderAreaStructures(siteKey, locale, apiBaseUrl, internalToken, runtimeModuleCatalog)).get(area);
+    if (!structure) {
+        throw new Error(`The builder structure read did not answer for area "${area}".`);
     }
-    const resolvedPreset = await getExactSiteArea({
-        apiBaseUrl,
-        internalToken,
-        siteKey,
-        path,
-        locale,
-        cookieHeader,
-        sourcePreset,
-    }).catch((error) => {
-        throw new Error(`Failed to resolve builder structure shell for area "${area}" at "${path}".`, { cause: error });
-    });
-    if (resolvedPreset?.preset) {
-        return buildPhiProjectedBuilderRegionDrafts(runtime, resolvedPreset.preset, area, null, PHI_BUILDER_SHELL_REGION_KEYS);
+    return structure;
+}
+const buildShellDraftsForArea = cache(async function buildShellDraftsForArea(runtime, siteKey, locale, apiBaseUrl, internalToken, area, runtimeModuleCatalog) {
+    const { draft, published } = await loadPhiBuilderAreaStructure(siteKey, locale, apiBaseUrl, internalToken, area, runtimeModuleCatalog);
+    const stored = draft ?? published;
+    if (stored) {
+        return buildPhiProjectedBuilderRegionDrafts(runtime, stored, area, null, PHI_BUILDER_SHELL_REGION_KEYS);
     }
     const installedTree = await instantiateAreaShellPresetTree(runtime, area, runtimeModuleCatalog);
     if (!installedTree) {
@@ -124,38 +162,12 @@ const buildShellDraftsForArea = cache(async function buildShellDraftsForArea(run
  * Read once and read whole, because everything the Shell says about itself arrives in the same
  * revision: the root route and the two SEO answers are one fetch, not one each.
  */
-const buildPhiBuilderAreaPresetConfig = cache(async function buildPhiBuilderAreaPresetConfig(runtime, area, runtimeModuleCatalog) {
-    const path = resolveStructureAreaPath(area);
-    const sourcePreset = resolveAreaPresetSource(area, runtimeModuleCatalog);
-    const cookieHeader = (await cookies()).toString();
-    const request = {
-        apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl,
-        internalToken: readPhiServerApiCredentials().internalToken,
-        siteKey: runtime.site.key,
-        path,
-        locale: runtime.locale.current,
-        cookieHeader,
-        sourcePreset,
-    };
-    // A failed read is not "never asked": answering with the preset default would let the Builder show and
-    // save it over what the Area actually stores.
-    const draftPreset = await getCurrentSiteAreaDraft({ ...request, area }).catch((error) => {
-        throw new Error(`Failed to resolve builder structure draft config for area "${area}" at "${path}".`, {
-            cause: error,
-        });
-    });
-    if (draftPreset?.preset) {
-        return draftPreset.preset.preset.config ?? null;
-    }
-    const resolvedPreset = await getExactSiteArea(request).catch((error) => {
-        throw new Error(`Failed to resolve builder structure config for area "${area}" at "${path}".`, {
-            cause: error,
-        });
-    });
-    return resolvedPreset?.preset ? resolvedPreset.preset.preset.config ?? null : null;
-});
+async function buildPhiBuilderAreaPresetConfig(runtime, area, runtimeModuleCatalog) {
+    const { draft, published } = await loadPhiBuilderAreaStructure(runtime.site.key, runtime.locale.current, readPhiServerApiCredentials().apiBaseUrl, readPhiServerApiCredentials().internalToken, area, runtimeModuleCatalog);
+    return (draft ?? published)?.preset.config ?? null;
+}
 /** What an Area says its `/` resolves to. */
-export async function buildPhiBuilderAreaRootRoute(runtime, area, runtimeModuleCatalog) {
+async function buildPhiBuilderAreaRootRoute(runtime, area, runtimeModuleCatalog) {
     return readPhiAreaRootRoute(await buildPhiBuilderAreaPresetConfig(runtime, area, runtimeModuleCatalog));
 }
 /**
@@ -170,7 +182,7 @@ export async function buildPhiBuilderAreaLandingSelection(runtime, area, runtime
     return resolvePhiAreaLandingSelection(await buildPhiBuilderAreaRootRoute(runtime, area, runtimeModuleCatalog));
 }
 /** What an Area says about being found. */
-export async function buildPhiBuilderAreaMeta(runtime, area, runtimeModuleCatalog) {
+async function buildPhiBuilderAreaMeta(runtime, area, runtimeModuleCatalog) {
     return readPhiAreaMeta(await buildPhiBuilderAreaPresetConfig(runtime, area, runtimeModuleCatalog));
 }
 export function resolvePhiBuilderCurrentStructureArea(runtime) {
@@ -193,37 +205,10 @@ export const buildPhiBuilderStructureShellDraftsForArea = cache(async function b
  * worse, could read a different revision than the Module selection it belongs to.
  */
 const buildRuntimeModulesConfigForArea = cache(async function buildRuntimeModulesConfigForArea(runtime, siteKey, locale, apiBaseUrl, internalToken, area, runtimeModuleCatalog) {
-    const path = resolveStructureAreaPath(area);
-    const sourcePreset = resolveAreaPresetSource(area, runtimeModuleCatalog);
-    const cookieHeader = (await cookies()).toString();
-    const draftPreset = await getCurrentSiteAreaDraft({
-        apiBaseUrl,
-        internalToken,
-        siteKey,
-        area,
-        path,
-        locale,
-        cookieHeader,
-        sourcePreset,
-    }).catch((error) => {
-        throw new Error(`Failed to resolve builder structure draft for area "${area}" at "${path}".`, { cause: error });
-    });
-    if (draftPreset?.preset) {
-        return readRuntimeModulesConfigFromStructureTree(draftPreset.preset, area, runtimeModuleCatalog);
-    }
-    const resolvedPreset = await getExactSiteArea({
-        apiBaseUrl,
-        internalToken,
-        siteKey,
-        path,
-        locale,
-        cookieHeader,
-        sourcePreset,
-    }).catch((error) => {
-        throw new Error(`Failed to resolve builder structure shell for area "${area}" at "${path}".`, { cause: error });
-    });
-    if (resolvedPreset?.preset) {
-        return readRuntimeModulesConfigFromStructureTree(resolvedPreset.preset, area, runtimeModuleCatalog);
+    const { draft, published } = await loadPhiBuilderAreaStructure(siteKey, locale, apiBaseUrl, internalToken, area, runtimeModuleCatalog);
+    const stored = draft ?? published;
+    if (stored) {
+        return readRuntimeModulesConfigFromStructureTree(stored, area, runtimeModuleCatalog);
     }
     return readRuntimeModulesConfigFromStructureTree(await instantiateAreaShellPresetTree(runtime, area, runtimeModuleCatalog), area, runtimeModuleCatalog);
 });
@@ -291,6 +276,23 @@ export async function buildPhiBuilderAreaMetaByArea(runtime, runtimeModuleCatalo
     ]));
     return Object.fromEntries(entries);
 }
+/**
+ * What every Area's Shell tells its Controllers, from the same chain the drafts come from: the open
+ * structure draft, else what is published, else the code-owned Shell. Carried into every structure save
+ * and every Module save baseline, which state the tree whole.
+ */
+export async function buildPhiBuilderAreaControllerSettingsByArea(runtime, runtimeModuleCatalog) {
+    const areas = PHI_BUILDER_AREA_KEYS;
+    const entries = await Promise.all(areas.map(async (area) => {
+        const { draft, published } = await loadPhiBuilderAreaStructure(runtime.site.key, runtime.locale.current, readPhiServerApiCredentials().apiBaseUrl, readPhiServerApiCredentials().internalToken, area, runtimeModuleCatalog);
+        const stored = draft ?? published;
+        const settings = stored
+            ? stored.controllerSettings ?? []
+            : (await instantiateAreaShellPresetTree(runtime, area, runtimeModuleCatalog))?.controllerSettings ?? [];
+        return [area, settings];
+    }));
+    return Object.fromEntries(entries);
+}
 export async function buildPhiBuilderStructureShellPresetDraftsByArea(runtime, runtimeModuleCatalog) {
     const areas = PHI_BUILDER_AREA_KEYS;
     const entries = await Promise.all(areas.map(async (area) => [

package/plugins/runtime-modules/builder/authoring-provider-keys.d.ts

@@ -1,24 +1,5 @@
 import type { PhiRuntimeDataProviderKey } from "../../../types/runtime-data-provider";
-import type { PhiRuntimeModuleCatalog, PhiRuntimeModuleDataProviderDescriptor } from "../../../types/cms-plugins";
-/**
- * Data providers the Builder's OWN chrome binds, independent of the Area being edited.
- *
- * The Asset picker a Markdown or Rich Text Widget offers from its toolbar, and the Background picker in
- * the Inspector, are Builder surfaces reaching into the Site's Media library. Neither depends on the
- * edited Area activating the Assets Module: a `phis:asset/...` reference is resolved by the core
- * reference resolver, so an Area without that Module still renders its images. Gating the picker on the
- * Module left it reporting "not available from the active runtime modules" over an empty library.
- *
- * Which Widgets an author may place still follows the Area's active modules. This is only about what
- * the Builder's own pickers can read.
- *
- * The set is collected from the catalog rather than listed here, because a list inside the Builder can
- * only ever name first-party providers: an installed package cannot write itself into this file. The
- * owning Module declares `availableToAuthoringChrome` on its provider descriptor instead.
- */
-export declare function resolvePhiBuilderAuthoringPickerDataProviderKeys(entries: readonly {
-    dataProviderDescriptors: readonly PhiRuntimeModuleDataProviderDescriptor[];
-}[]): readonly PhiRuntimeDataProviderKey[];
+import type { PhiRuntimeModuleCatalog } from "../../../types/cms-plugins";
 /**
  * The same set, read from the install catalog a request resolved.
  *

package/plugins/runtime-modules/builder/authoring-provider-keys.js

@@ -14,7 +14,7 @@
  * only ever name first-party providers: an installed package cannot write itself into this file. The
  * owning Module declares `availableToAuthoringChrome` on its provider descriptor instead.
  */
-export function resolvePhiBuilderAuthoringPickerDataProviderKeys(entries) {
+function resolvePhiBuilderAuthoringPickerDataProviderKeys(entries) {
     const keys = new Set();
     for (const entry of entries) {
         for (const descriptor of entry.dataProviderDescriptors) {

package/plugins/runtime-modules/builder/authoring-widgets.js

@@ -1,6 +1,5 @@
 "use client";
 import { PHI_BUILDER_INSPECTOR_SECTION_WIDGET_DEFINITIONS, PHI_BUILDER_INSPECTOR_HEADER_WIDGET_DEFINITION, PHI_BUILDER_MODE_SWITCH_WIDGET_DEFINITION, } from "./widgets/chrome/config";
-import { PHI_BUILDER_CHROME_CONTROLS_WIDGET_DEFINITION, } from "./widgets/chrome-controls/config";
 import { PHI_DEVELOPER_BUILDER_PAGES_HEADER_WIDGET_DEFINITION, } from "./widgets/workspace-headers/config";
 import { PHI_BUILDER_PAGES_WORKSPACE_WIDGET_DEFINITION, PHI_BUILDER_SHELLS_WORKSPACE_WIDGET_DEFINITION, } from "./widgets/workspaces/config";
 import { PHI_HELLO_WORLD_WIDGET_DEFINITION, } from "./widgets/hello-world/config";
@@ -9,7 +8,6 @@ import { PHI_TEST_BLOCK_WIDGET_DEFINITION, } from "./widgets/test-block/config";
 import { createPhiAuthoringWidgetModule, definePhiAuthoringWidgetModuleLoader, } from "../client-authoring-widget-module";
 export default createPhiAuthoringWidgetModule([
     definePhiAuthoringWidgetModuleLoader(PHI_BUILDER_INSPECTOR_HEADER_WIDGET_DEFINITION, () => import("./widgets/inspector-header/authoring").then((module) => module.PHI_BUILDER_INSPECTOR_HEADER_WIDGET_BUILDER_PLUGIN)),
-    definePhiAuthoringWidgetModuleLoader(PHI_BUILDER_CHROME_CONTROLS_WIDGET_DEFINITION, () => import("./widgets/chrome-controls/authoring").then((module) => module.PHI_BUILDER_CHROME_CONTROLS_WIDGET_BUILDER_PLUGIN)),
     ...PHI_BUILDER_INSPECTOR_SECTION_WIDGET_DEFINITIONS.map(({ definition }) => definePhiAuthoringWidgetModuleLoader(definition, () => import("./widgets/inspector-section/authoring").then((module) => module.createPhiBuilderInspectorSectionWidgetBuilderPlugin(definition)))),
     definePhiAuthoringWidgetModuleLoader(PHI_BUILDER_MODE_SWITCH_WIDGET_DEFINITION, () => import("./widgets/mode-switch/authoring").then((module) => module.PHI_BUILDER_MODE_SWITCH_WIDGET_BUILDER_PLUGIN)),
     definePhiAuthoringWidgetModuleLoader(PHI_BUILDER_PAGES_WORKSPACE_WIDGET_DEFINITION, () => import("./widgets/pages-workspace/authoring").then((module) => module.PHI_BUILDER_PAGES_WORKSPACE_WIDGET_BUILDER_PLUGIN)),

package/plugins/runtime-modules/builder/cards.d.ts

@@ -0,0 +1,3 @@
+import "server-only";
+import { type PhiDashboardCardProvider } from "../../../types/dashboard-cards";
+export declare const PHI_BUILDER_RUNTIME_MODULE_DASHBOARD_CARDS: PhiDashboardCardProvider;

package/plugins/runtime-modules/builder/cards.js

@@ -0,0 +1,79 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiRuntimeModuleLabelSet, getPhiLabelSet } from "../../../gateway/label-set";
+import { getPhiBuilderModulesPageLabels } from "../../../components/widgets/label-sets/builder-modules";
+import { PHI_FIRST_PARTY_RUNTIME_MODULE_CATALOG } from "../catalog";
+import { createPhiDashboardCardId, } from "../../../types/dashboard-cards";
+import { readPhiBuilderAreasWithOpenDraft } from "./area-shell-presets.server";
+import { PHI_BUILDER_RUNTIME_MODULE_ID, PHI_BUILDER_RUNTIME_MODULE_IDENTITY } from "./ids";
+/**
+ * What is open on the Builder's Dashboard: the Areas whose structure has a draft nobody published.
+ *
+ * The first `list` card. A structure author opening the Builder wants to know where they left off,
+ * which is a set of names rather than a count -- "Public and App" says where to go, "2" does not.
+ *
+ * The Area shells are read from the first-party catalog. A provider is handed no catalog, and every
+ * Area's shell is contributed by its first-party base Module, so the Builder's catalog and this one name
+ * the same shell sources; a Site's own Modules add Pages, not Areas.
+ */
+const PHI_BUILDER_DASHBOARD_CARD_LABEL_SET = definePhiRuntimeModuleLabelSet(PHI_BUILDER_RUNTIME_MODULE_IDENTITY, {
+    key: "cards:builder-drafts",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        drafts_eyebrow: "Structure",
+        drafts_title: "Open drafts",
+        drafts_description: "Areas whose Shell or Module selection has changes that are not published",
+        drafts_meta_waiting: "Publish them under Shells",
+        drafts_meta_clear: "Every Area is published",
+    },
+});
+const PHI_BUILDER_DRAFTS_CARD_ID = createPhiDashboardCardId(PHI_BUILDER_RUNTIME_MODULE_ID, "drafts");
+function readTranslatorOptions(context) {
+    return {
+        apiBaseUrl: context.apiBaseUrl,
+        internalToken: context.internalToken,
+        locale: context.locale,
+    };
+}
+export const PHI_BUILDER_RUNTIME_MODULE_DASHBOARD_CARDS = {
+    async listCards(context) {
+        const labels = await getPhiLabelSet(readTranslatorOptions(context), PHI_BUILDER_DASHBOARD_CARD_LABEL_SET);
+        return [{
+                cardId: PHI_BUILDER_DRAFTS_CARD_ID,
+                form: "list",
+                eyebrow: labels.drafts_eyebrow,
+                title: labels.drafts_title,
+                description: labels.drafts_description,
+                mark: "antd:edit",
+                target: {
+                    ownerModuleId: PHI_BUILDER_RUNTIME_MODULE_ID,
+                    presetKey: "builder-shells-page",
+                },
+            }];
+    },
+    async resolveCard(cardId, context) {
+        if (cardId !== PHI_BUILDER_DRAFTS_CARD_ID) {
+            throw new Error(`Unknown Builder Dashboard card "${cardId}".`);
+        }
+        const options = readTranslatorOptions(context);
+        const [labels, areaLabels, drafted] = await Promise.all([
+            getPhiLabelSet(options, PHI_BUILDER_DASHBOARD_CARD_LABEL_SET),
+            getPhiBuilderModulesPageLabels(options).then((page) => page.areas),
+            readPhiBuilderAreasWithOpenDraft(PHI_FIRST_PARTY_RUNTIME_MODULE_CATALOG, {
+                siteKey: context.siteKey,
+                locale: context.locale,
+                apiBaseUrl: context.apiBaseUrl,
+                internalToken: context.internalToken,
+            }),
+        ]);
+        return {
+            cardId,
+            // The Area's name alone: the card's title already says what is open about it.
+            entries: drafted.map((area) => ({ key: area, content: areaLabels[area], tone: "warning" })),
+            description: labels.drafts_description,
+            meta: drafted.length > 0 ? labels.drafts_meta_waiting : labels.drafts_meta_clear,
+            error: null,
+            resolvedAt: new Date().toISOString(),
+        };
+    },
+};

package/plugins/runtime-modules/builder/clients/builder-region-overrides.js

@@ -2,6 +2,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { resolvePhiBuilderSiderWidth } from "../builder-geometry";
+import { hasPhiConfigFlag } from "../../../../helpers/flags";
+import { PhiCmsFlags } from "../../../../constants/phi-cms";
 import { PhiAuthoringRegionOverridesProvider } from "../../../../components/runtime/authoring-region-overrides";
 import { getDefaultRegionDraft, resolveRegionDraftKey } from "../developer-region-drafts";
 import { usePhiDeveloperBuilderStateValue, usePhiDeveloperRegionDrafts } from "../developer-workspace-store";
@@ -15,8 +17,8 @@ export function PhiBuilderCanvasRegionOverrides({ children }) {
         const siderLeft = resolveRegionDraftKey(regionDrafts, area, "sider_left", pageKey) ?? getDefaultRegionDraft("sider_left");
         return {
             preview: builderMode === "preview",
-            pageSiderRight: { visible: siderRight.rootNodeTypeKey != null, width: resolvePhiBuilderSiderWidth(siderRight) },
-            structureSiderLeft: { visible: siderLeft.rootNodeTypeKey != null, width: resolvePhiBuilderSiderWidth(siderLeft), fullHeight: siderLeft.regionConfig?.fullHeight === true },
+            pageSiderRight: { visible: siderRight.rootNode != null, width: resolvePhiBuilderSiderWidth(siderRight) },
+            structureSiderLeft: { visible: siderLeft.rootNode != null, width: resolvePhiBuilderSiderWidth(siderLeft), fullHeight: hasPhiConfigFlag(siderLeft.regionConfig, PhiCmsFlags.FullHeight) },
         };
     }, [area, builderMode, pageKey, regionDrafts]);
     return _jsx(PhiAuthoringRegionOverridesProvider, { value: value, children: children });

package/plugins/runtime-modules/builder/clients/canvas-widget.js

@@ -1,8 +1,8 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useMemo } from "react";
+import { useCallback, useEffect, useMemo } from "react";
 import { PhiDeveloperBuilderStructureCanvas, } from "./structure-canvas";
-import { mergePhiDeveloperRegionDrafts, usePhiDeveloperBuilderStateValue, usePhiDeveloperRegionDrafts, } from "../developer-workspace-store";
+import { getPhiDeveloperRegionDraftsSnapshot, mergePhiDeveloperRegionDrafts, usePhiDeveloperBuilderStateValue, usePhiDeveloperRegionDraftsValue, } from "../developer-workspace-store";
 import { getPhiBuilderRegionDraftKey, PHI_BUILDER_PAGE_REGION_KEYS, PHI_BUILDER_SHELL_REGION_KEYS, } from "../region-keys";
 import { usePhiBuilderModuleMetas } from "../plugin-meta-store";
 import { buildPhiStructureRegionPickItems } from "../structure-region-pick-items";
@@ -11,11 +11,22 @@ export function PhiDeveloperBuilderCanvasWidgetClient({ workspace, serverPreview
     const area = usePhiDeveloperBuilderStateValue("public", (state) => state.area);
     const pageKey = usePhiDeveloperBuilderStateValue("public", (state) => state.pageKey);
     const builderMode = usePhiDeveloperBuilderStateValue("public", (state) => state.builderMode);
-    const regionDrafts = usePhiDeveloperRegionDrafts();
     const builderModuleMetas = usePhiBuilderModuleMetas(targetArea);
     const pickItems = useMemo(() => buildPhiStructureRegionPickItems(builderModuleMetas.plugins), [builderModuleMetas.plugins]);
     const isStructureWorkspace = workspace === "structure";
     const isPagesWorkspace = workspace === "pages";
+    /*
+     * Which of this workspace's drafts are not in the store, as one string. The Canvas used to subscribe
+     * to the whole draft map for this question, so every write to any draft re-rendered it and, below it,
+     * every Region scaffold on the canvas with its whole tree. The Regions read their own draft now
+     * (`structure-canvas.tsx`); this widget renders when the set of missing drafts changes and not before.
+     */
+    const hydrationDraftKeys = useMemo(() => (isStructureWorkspace
+        ? PHI_BUILDER_SHELL_REGION_KEYS.map((regionKey) => getPhiBuilderRegionDraftKey(area, regionKey, pageKey))
+        : isPagesWorkspace
+            ? PHI_BUILDER_PAGE_REGION_KEYS.map((regionKey) => getPhiBuilderRegionDraftKey(area, regionKey, pageKey))
+            : []), [area, isPagesWorkspace, isStructureWorkspace, pageKey]);
+    const missingDraftKeys = usePhiDeveloperRegionDraftsValue(useCallback((drafts) => hydrationDraftKeys.filter((draftKey) => drafts[draftKey] == null).join("\u0000"), [hydrationDraftKeys]));
     useEffect(() => {
         if (!isStructureWorkspace && !isPagesWorkspace) {
             return;
@@ -23,6 +34,7 @@ export function PhiDeveloperBuilderCanvasWidgetClient({ workspace, serverPreview
         if (builderMode === "preview" && previewRegionDrafts && Object.keys(previewRegionDrafts).length > 0) {
             mergePhiDeveloperRegionDrafts(previewRegionDrafts);
         }
+        const regionDrafts = getPhiDeveloperRegionDraftsSnapshot();
         const shellDraftKeys = PHI_BUILDER_SHELL_REGION_KEYS
             .map((regionKey) => getPhiBuilderRegionDraftKey(area, regionKey, pageKey));
         const pageDraftKeys = PHI_BUILDER_PAGE_REGION_KEYS
@@ -46,22 +58,23 @@ export function PhiDeveloperBuilderCanvasWidgetClient({ workspace, serverPreview
             mergePhiDeveloperRegionDrafts(missingPageDrafts);
             return;
         }
+        // `missingDraftKeys` is the reason to run again; the snapshot inside is what is read.
     }, [
         isPagesWorkspace,
         isStructureWorkspace,
+        missingDraftKeys,
         pageDraftsByScope,
         previewRegionDrafts,
-        regionDrafts,
         area,
         builderMode,
         pageKey,
         structureShellDraftsByArea,
     ]);
     if (isStructureWorkspace) {
-        return (_jsx(PhiDeveloperBuilderStructureCanvas, { workspace: "structure", builderMode: builderMode, area: area, pageKey: pageKey, shellTheme: shellTheme, regionDrafts: regionDrafts, pageDraftsByScope: pageDraftsByScope, serverPreviewRegions: serverPreviewRegions, pickItems: pickItems, regionLabels: regionLabels, pickerLabels: pickerLabels }));
+        return (_jsx(PhiDeveloperBuilderStructureCanvas, { workspace: "structure", builderMode: builderMode, area: area, pageKey: pageKey, shellTheme: shellTheme, pageDraftsByScope: pageDraftsByScope, serverPreviewRegions: serverPreviewRegions, pickItems: pickItems, regionLabels: regionLabels, pickerLabels: pickerLabels }));
     }
     if (isPagesWorkspace) {
-        return (_jsx(PhiDeveloperBuilderStructureCanvas, { workspace: "pages", builderMode: builderMode, area: area, pageKey: pageKey, shellTheme: shellTheme, regionDrafts: regionDrafts, serverPreviewRegions: serverPreviewRegions, pickItems: pickItems, regionLabels: regionLabels, pickerLabels: pickerLabels }));
+        return (_jsx(PhiDeveloperBuilderStructureCanvas, { workspace: "pages", builderMode: builderMode, area: area, pageKey: pageKey, shellTheme: shellTheme, serverPreviewRegions: serverPreviewRegions, pickItems: pickItems, regionLabels: regionLabels, pickerLabels: pickerLabels }));
     }
     return null;
 }