@phis/ui 0.1.0

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

@@ -0,0 +1,283 @@
+import { normalizePhiViewportFlags } from "../../../types/access";
+import { findPhiBuilderLayoutNodeById, findPhiBuilderWidgetNodeByIdInLayouts, findPhiBuilderWidgetNodeByIdInWidgets, } from "./node-finders";
+import { getDefaultRegionDraft, resolveRegionDraftKey, } from "./developer-region-drafts";
+import { getPhiBuilderRegionDraftKey, isPhiBuilderPageScopedRegion, } from "./region-keys";
+import { createPhiBuilderRegionHistoryContext } from "./history";
+import { assertPhiCmsConfigFields } from "../../../helpers/cms-config-field-validation";
+import { getPhiBuilderModuleMetasSnapshot } from "./plugin-meta-store";
+import { builderWorkspaceStore, getPhiDeveloperRegionDraftsSnapshot, setPhiDeveloperRegionDraft, getPhiDeveloperBuilderStateSnapshot, } from "./developer-workspace-store";
+function patchLayoutNodeById(nodes, nodeId, patchConfig) {
+    return nodes.map((node) => {
+        if (node.id === nodeId) {
+            return {
+                ...node,
+                config: patchConfig(node.config ?? {}),
+            };
+        }
+        return {
+            ...node,
+            childLayouts: patchLayoutNodeById(node.childLayouts ?? [], nodeId, patchConfig),
+        };
+    });
+}
+function patchWidgetNodeById(widgets, nodeId, patchConfig) {
+    return widgets.map((node) => {
+        if (node.id === nodeId) {
+            return {
+                ...node,
+                config: patchConfig(node.config ?? {}),
+            };
+        }
+        return node;
+    });
+}
+function patchWidgetNodeByIdInLayouts(nodes, nodeId, patchConfig) {
+    return nodes.map((node) => ({
+        ...node,
+        childLayouts: patchWidgetNodeByIdInLayouts(node.childLayouts ?? [], nodeId, patchConfig),
+        childWidgets: patchWidgetNodeById(node.childWidgets ?? [], nodeId, patchConfig),
+    }));
+}
+/**
+ * The write path's one gate.
+ *
+ * A control is drawn from the same field declaration this checks against, so nobody clicking through
+ * the Builder can produce a value that fails here -- what can is a patch written in code, and that is
+ * exactly what should not reach a stored page quietly. Reading stays forgiving; writing does not.
+ *
+ * A type with no metadata in the active Canvas is left alone rather than refused: the catalogue is
+ * per Area, and a node from elsewhere is a question about scope, not about this value.
+ */
+function assertPhiBuilderPatchedConfig(area, widgetType, config) {
+    const meta = getPhiBuilderModuleMetasSnapshot(area).plugins
+        .find((candidate) => `${candidate.pluginKey}/${candidate.typeKey}` === widgetType);
+    if (!meta?.fields) {
+        return;
+    }
+    assertPhiCmsConfigFields(meta.fields, config, meta.title ?? widgetType);
+}
+function guardPhiBuilderConfigPatch(area, widgetType, patchConfig) {
+    return (config) => {
+        const next = patchConfig(config);
+        assertPhiBuilderPatchedConfig(area, widgetType, next);
+        return next;
+    };
+}
+function resolveWidgetSizeFromGeometry(geometry) {
+    return {
+        size: geometry.size ?? undefined,
+        minSize: geometry.minSize ?? undefined,
+        maxSize: geometry.maxSize ?? undefined,
+        ...(typeof geometry.zIndex === "number"
+            ? { zIndex: geometry.zIndex }
+            : {}),
+        viewportFlags: normalizePhiViewportFlags(geometry.viewportFlags),
+    };
+}
+function resolvePaddingPatch(padding) {
+    return padding == null
+        ? {
+            padding: undefined,
+            gap: undefined,
+            paddingTop: undefined,
+            paddingRight: undefined,
+            paddingBottom: undefined,
+            paddingLeft: undefined,
+        }
+        : {
+            padding: padding.padding,
+            gap: padding.gap,
+            paddingTop: padding.paddingTop,
+            paddingRight: padding.paddingRight,
+            paddingBottom: padding.paddingBottom,
+            paddingLeft: padding.paddingLeft,
+        };
+}
+function resolveInspectorHistoryContext(state, regionKey) {
+    return createPhiBuilderRegionHistoryContext({
+        area: state.area,
+        pageKey: state.pageKey,
+        pageScoped: isPhiBuilderPageScopedRegion(regionKey),
+    });
+}
+/**
+ * One authoring gesture, one history entry. The field being edited and the node it belongs to are what
+ * separate a slider still being dragged from a second, considered edit; the store adds the timing.
+ */
+function resolveInspectorCoalesceKey(state, draftKey, field) {
+    return `${draftKey}:${state.nodeId ?? "root"}:${field}`;
+}
+function patchSelectedWidgetDraftConfig(state, field, patchConfig) {
+    if (!state.selectedRootRegionKey || state.nodeId == null) {
+        return false;
+    }
+    const draftKey = getPhiBuilderRegionDraftKey(state.area, state.selectedRootRegionKey, state.pageKey);
+    const selectedRootDraft = resolveRegionDraftKey(getPhiDeveloperRegionDraftsSnapshot(), state.area, state.selectedRootRegionKey, state.pageKey);
+    if (!selectedRootDraft) {
+        return false;
+    }
+    const selectedWidgetNode = findPhiBuilderWidgetNodeByIdInWidgets(selectedRootDraft.rootNodeChildWidgets ?? [], state.nodeId) ??
+        findPhiBuilderWidgetNodeByIdInLayouts(selectedRootDraft.rootNodeChildLayouts ?? [], state.nodeId);
+    if (!selectedWidgetNode) {
+        return false;
+    }
+    const guardedPatch = guardPhiBuilderConfigPatch(state.area, selectedWidgetNode.widgetType, patchConfig);
+    setPhiDeveloperRegionDraft(draftKey, {
+        ...selectedRootDraft,
+        rootNodeChildWidgets: patchWidgetNodeById(selectedRootDraft.rootNodeChildWidgets ?? [], state.nodeId, guardedPatch),
+        rootNodeChildLayouts: patchWidgetNodeByIdInLayouts(selectedRootDraft.rootNodeChildLayouts ?? [], state.nodeId, guardedPatch),
+    }, {
+        historyContext: resolveInspectorHistoryContext(state, state.selectedRootRegionKey),
+        historyLabel: "Update widget",
+        historyCoalesceKey: resolveInspectorCoalesceKey(state, draftKey, field),
+    });
+    return true;
+}
+function patchSelectedStructureDraftConfig(state, field, patchConfig) {
+    if (!state.selectedRootRegionKey || state.nodeId == null) {
+        return false;
+    }
+    const draftKey = getPhiBuilderRegionDraftKey(state.area, state.selectedRootRegionKey, state.pageKey);
+    const selectedRootDraft = resolveRegionDraftKey(getPhiDeveloperRegionDraftsSnapshot(), state.area, state.selectedRootRegionKey, state.pageKey);
+    const selectedRootNodeId = selectedRootDraft?.rootNodeId ?? null;
+    const selectedNestedLayoutNode = selectedRootDraft && state.nodeId !== selectedRootNodeId
+        ? findPhiBuilderLayoutNodeById(selectedRootDraft.rootNodeChildLayouts ?? [], state.nodeId)
+        : null;
+    if (!selectedRootDraft || !selectedNestedLayoutNode) {
+        return false;
+    }
+    setPhiDeveloperRegionDraft(draftKey, {
+        ...selectedRootDraft,
+        rootNodeChildLayouts: patchLayoutNodeById(selectedRootDraft.rootNodeChildLayouts ?? [], state.nodeId, guardPhiBuilderConfigPatch(state.area, selectedNestedLayoutNode.widgetType, patchConfig)),
+    }, {
+        historyContext: resolveInspectorHistoryContext(state, state.selectedRootRegionKey),
+        historyLabel: "Update layout",
+        historyCoalesceKey: resolveInspectorCoalesceKey(state, draftKey, field),
+    });
+    return true;
+}
+function patchSelectedRootStructureConfig(state, field, patch) {
+    if (!state.selectedRootRegionKey) {
+        return false;
+    }
+    const draftKey = getPhiBuilderRegionDraftKey(state.area, state.selectedRootRegionKey, state.pageKey);
+    const selectedRootDraft = resolveRegionDraftKey(getPhiDeveloperRegionDraftsSnapshot(), state.area, state.selectedRootRegionKey, state.pageKey);
+    if (!selectedRootDraft) {
+        return false;
+    }
+    setPhiDeveloperRegionDraft(draftKey, {
+        ...selectedRootDraft,
+        rootNodeConfig: {
+            ...(selectedRootDraft.rootNodeConfig ?? {}),
+            ...patch,
+        },
+        ...patch,
+    }, {
+        historyContext: resolveInspectorHistoryContext(state, state.selectedRootRegionKey),
+        historyLabel: "Update layout",
+        historyCoalesceKey: resolveInspectorCoalesceKey(state, draftKey, field),
+    });
+    return true;
+}
+function readRecordPatch(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function runPhiDeveloperBuilderInspectorAction(defaultArea, action) {
+    const state = getPhiDeveloperBuilderStateSnapshot(defaultArea);
+    if (action.kind === "patchSelectedRegionDraft") {
+        const patch = readRecordPatch(action.patch);
+        const selectedRegionKey = state.nodeKind === "region" ? state.nodeKey.replace(/^region:/, "") : null;
+        const currentDraft = selectedRegionKey
+            ? resolveRegionDraftKey(getPhiDeveloperRegionDraftsSnapshot(), state.area, selectedRegionKey, state.pageKey) ?? getDefaultRegionDraft(selectedRegionKey)
+            : null;
+        if (!selectedRegionKey || !currentDraft || !patch) {
+            return;
+        }
+        setPhiDeveloperRegionDraft(getPhiBuilderRegionDraftKey(state.area, selectedRegionKey, state.pageKey), {
+            ...currentDraft,
+            ...patch,
+        }, {
+            historyContext: resolveInspectorHistoryContext(state, selectedRegionKey),
+            historyLabel: "Update region",
+            historyCoalesceKey: resolveInspectorCoalesceKey(state, getPhiBuilderRegionDraftKey(state.area, selectedRegionKey, state.pageKey), Object.keys(patch).sort().join(",")),
+        });
+        return;
+    }
+    if (action.kind === "patchSelectedWidgetConfig") {
+        const patch = readRecordPatch(action.patch);
+        if (patch) {
+            patchSelectedWidgetDraftConfig(state, Object.keys(patch).sort().join(","), (config) => ({ ...config, ...patch }));
+        }
+        return;
+    }
+    if (action.kind === "patchSelectedWidgetGeometry") {
+        const geometry = readRecordPatch(action.geometry);
+        if (geometry) {
+            patchSelectedWidgetDraftConfig(state, "geometry", (config) => ({
+                ...config,
+                ...resolveWidgetSizeFromGeometry(geometry),
+            }));
+        }
+        return;
+    }
+    if (action.kind === "patchSelectedLayoutAnchor") {
+        const selectedLayoutAnchor = action.selectedLayoutAnchor;
+        if (typeof selectedLayoutAnchor !== "string") {
+            return;
+        }
+        if (!patchSelectedStructureDraftConfig(state, "anchor", (config) => ({ ...config, anchor: selectedLayoutAnchor }))) {
+            patchSelectedRootStructureConfig(state, "anchor", { rootNodeAnchor: selectedLayoutAnchor });
+        }
+        builderWorkspaceStore.patch(defaultArea, (current) => ({
+            ...current,
+            selectedLayoutAnchor: selectedLayoutAnchor,
+        }));
+        return;
+    }
+    if (action.kind === "patchSelectedLayoutPadding") {
+        const padding = action.padding == null ? null : readRecordPatch(action.padding);
+        if (!patchSelectedStructureDraftConfig(state, "padding", (config) => ({
+            ...config,
+            ...resolvePaddingPatch(padding),
+        }))) {
+            patchSelectedRootStructureConfig(state, "padding", { rootNodePadding: padding });
+        }
+        return;
+    }
+    if (action.kind === "patchSelectedLayoutBackground") {
+        if (!patchSelectedStructureDraftConfig(state, "background", (config) => ({
+            ...config,
+            rootNodeBackground: action.background,
+        }))) {
+            patchSelectedRootStructureConfig(state, "background", { rootNodeBackground: action.background });
+        }
+        return;
+    }
+    if (action.kind === "patchSelectedLayoutBorder") {
+        if (!patchSelectedStructureDraftConfig(state, "border", (config) => ({
+            ...config,
+            rootNodeBorder: action.border,
+        }))) {
+            patchSelectedRootStructureConfig(state, "border", { rootNodeBorder: action.border });
+        }
+        return;
+    }
+    if (action.kind === "patchSelectedLayoutShadow") {
+        const shadow = action.shadow;
+        if (!patchSelectedStructureDraftConfig(state, "shadow", (config) => ({ ...config, rootNodeShadow: shadow }))) {
+            patchSelectedRootStructureConfig(state, "shadow", { rootNodeShadow: shadow });
+        }
+        return;
+    }
+    if (action.kind === "patchSelectedLayoutConfig" && typeof action.key === "string") {
+        const nextValue = action.value ?? undefined;
+        if (!patchSelectedStructureDraftConfig(state, action.key, (config) => ({
+            ...config,
+            [action.key]: nextValue,
+        }))) {
+            patchSelectedRootStructureConfig(state, action.key, { [action.key]: nextValue });
+        }
+    }
+}

package/plugins/runtime-modules/builder/inspector-overlay-addresses.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The preset these addresses belong to, which is the Builder's Overlay contribution and not its Area
+ * shell. The shell is a starting point an operator may save over; these Overlays are the tool doing
+ * the saving, so they are contributed to the Area rather than declared in the tree it replaces.
+ */
+export declare const PHI_BUILDER_INSPECTOR_OVERLAY_PRESET_KEY = "builder-inspector-overlay-preset";
+export declare const PHI_BUILDER_INSPECTOR_OVERLAY_IDS: Readonly<Record<"regionInspector" | "layoutInspector" | "widgetInspector" | "effectsEditor" | "signalWiring", import("@phis/contracts/cms").PhiCmsInstanceId>>;
+export declare const PHI_BUILDER_INSPECTOR_DRAWER_OVERLAY_IDS: readonly [import("@phis/contracts/cms").PhiCmsInstanceId, import("@phis/contracts/cms").PhiCmsInstanceId, import("@phis/contracts/cms").PhiCmsInstanceId];
+export declare const PHI_BUILDER_INSPECTOR_LAYOUT_IDS: Readonly<Record<"regionInspectorHeader" | "layoutInspectorHeader" | "widgetInspectorHeader" | "regionInspectorBody" | "layoutInspectorBody" | "widgetInspectorBody" | "effectsHeader" | "effectsBody" | "effectsFooter" | "signalWiringBody" | "signalWiringFooter", import("@phis/contracts/cms").PhiCmsInstanceId>>;
+export declare const PHI_BUILDER_INSPECTOR_WIDGET_IDS: Readonly<Record<"regionInspectorHeaderWidget" | "layoutInspectorHeaderWidget" | "widgetInspectorHeaderWidget" | "effectsTabs" | "effectsAppearanceForm" | "effectsTransitionsForm" | "effectsViewportForm" | "effectsCommands" | "signalWiringForm" | "signalWiringRoutes" | "signalWiringCommands", import("@phis/contracts/cms").PhiCmsInstanceId>>;
+export declare const PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS: {
+    readonly appearance: import("@phis/contracts/cms").PhiCmsInstanceId;
+    readonly transitions: import("@phis/contracts/cms").PhiCmsInstanceId;
+    readonly viewport: import("@phis/contracts/cms").PhiCmsInstanceId;
+};
+export declare const PHI_BUILDER_INSPECTOR_SECTION_WIDGET_IDS: Readonly<Record<"regionGeometry" | "regionViewport" | "regionPadding" | "regionBackground" | "regionBorder" | "regionShadow" | "layoutSettings" | "layoutAnchor" | "layoutViewport" | "layoutBackground" | "layoutBorder" | "layoutShadow" | "layoutSignals" | "widgetSettings" | "widgetGeometry" | "widgetViewport" | "widgetSignals" | "layoutPadding", import("@phis/contracts/cms").PhiCmsInstanceId>>;

package/plugins/runtime-modules/builder/inspector-overlay-addresses.js

@@ -0,0 +1,32 @@
+import { PHI_BUILDER_RUNTIME_MODULE_ID } from "../../../plugins/runtime-modules/builder/ids";
+import { createPhiPresetCmsInstanceIdMap } from "../../../types/cms-instance-id";
+/**
+ * The preset these addresses belong to, which is the Builder's Overlay contribution and not its Area
+ * shell. The shell is a starting point an operator may save over; these Overlays are the tool doing
+ * the saving, so they are contributed to the Area rather than declared in the tree it replaces.
+ */
+export const PHI_BUILDER_INSPECTOR_OVERLAY_PRESET_KEY = "builder-inspector-overlay-preset";
+const PHI_BUILDER_INSPECTOR_PRESET_IDENTITY = {
+    domain: "area",
+    ownerModuleId: PHI_BUILDER_RUNTIME_MODULE_ID,
+    presetKey: PHI_BUILDER_INSPECTOR_OVERLAY_PRESET_KEY,
+};
+export const PHI_BUILDER_INSPECTOR_OVERLAY_IDS = createPhiPresetCmsInstanceIdMap(PHI_BUILDER_INSPECTOR_PRESET_IDENTITY, ["regionInspector", "layoutInspector", "widgetInspector", "effectsEditor", "signalWiring"]);
+export const PHI_BUILDER_INSPECTOR_DRAWER_OVERLAY_IDS = [
+    PHI_BUILDER_INSPECTOR_OVERLAY_IDS.regionInspector,
+    PHI_BUILDER_INSPECTOR_OVERLAY_IDS.layoutInspector,
+    PHI_BUILDER_INSPECTOR_OVERLAY_IDS.widgetInspector,
+];
+export const PHI_BUILDER_INSPECTOR_LAYOUT_IDS = createPhiPresetCmsInstanceIdMap(PHI_BUILDER_INSPECTOR_PRESET_IDENTITY, ["regionInspectorHeader", "layoutInspectorHeader", "widgetInspectorHeader", "regionInspectorBody", "layoutInspectorBody", "widgetInspectorBody", "effectsHeader", "effectsBody", "effectsFooter", "signalWiringBody", "signalWiringFooter"]);
+export const PHI_BUILDER_INSPECTOR_WIDGET_IDS = createPhiPresetCmsInstanceIdMap(PHI_BUILDER_INSPECTOR_PRESET_IDENTITY, ["regionInspectorHeaderWidget", "layoutInspectorHeaderWidget", "widgetInspectorHeaderWidget", "effectsTabs", "effectsAppearanceForm", "effectsTransitionsForm", "effectsViewportForm", "effectsCommands", "signalWiringForm", "signalWiringRoutes", "signalWiringCommands"]);
+export const PHI_BUILDER_EFFECTS_FORM_WIDGET_IDS = {
+    appearance: PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsAppearanceForm,
+    transitions: PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsTransitionsForm,
+    viewport: PHI_BUILDER_INSPECTOR_WIDGET_IDS.effectsViewportForm,
+};
+export const PHI_BUILDER_INSPECTOR_SECTION_WIDGET_IDS = createPhiPresetCmsInstanceIdMap(PHI_BUILDER_INSPECTOR_PRESET_IDENTITY, [
+    "regionGeometry", "regionViewport", "regionPadding", "regionBackground", "regionBorder", "regionShadow",
+    "layoutSettings", "layoutAnchor", "layoutViewport", "layoutBackground", "layoutBorder", "layoutShadow", "layoutSignals",
+    "widgetSettings", "widgetGeometry", "widgetViewport", "widgetSignals",
+    "layoutPadding",
+]);

package/plugins/runtime-modules/builder/inspector-section-widget.d.ts

@@ -0,0 +1,10 @@
+import type { PhiBlockRuntime, PhiCmsRuntimeRenderRegistry } from "../../../types";
+import type { PhiSignalRouteSet } from "../../../types/signals";
+export type PhiBuilderInspectorSectionWidgetProps = {
+    runtime: PhiBlockRuntime;
+    registry: PhiCmsRuntimeRenderRegistry;
+    view: "region" | "layout" | "widget";
+    section?: string;
+    signalRoutes?: PhiSignalRouteSet;
+};
+export declare function PhiBuilderInspectorSectionWidget({ runtime, registry, view, section, signalRoutes, }: PhiBuilderInspectorSectionWidgetProps): Promise<import("react").JSX.Element>;

package/plugins/runtime-modules/builder/inspector-section-widget.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getPhiBorderWidgetLabels } from "../../../components/widgets/label-sets/border";
+import { getPhiBackgroundWidgetLabels } from "../../../components/widgets/label-sets/background";
+import { getPhiGeometryWidgetLabels } from "../../../components/widgets/label-sets/geometry";
+import { getPhiSignalsWidgetLabels } from "../../../components/widgets/label-sets/signals";
+import { getPhiColorPickerLabelsForRuntime } from "../../../components/widgets/label-sets/color-picker";
+import { PhiBuilderLayoutInspectorSectionWidgetClient, PhiBuilderRegionInspectorSectionWidgetClient, PhiBuilderWidgetInspectorSectionWidgetClient, } from "./clients/inspector-section-widget";
+import { buildPhiBuilderRuntimeModuleIdsForArea } from "./area-shell-presets.server";
+import { resolvePhiBuilderAreaAsCmsArea } from "../../../constants/cms-areas";
+import { PHI_BUILDER_AREA_SEARCH_PARAM, normalizePhiBuilderAreaSearchParam, } from "../../../helpers/cms-scope-search-params";
+import { resolvePhiRuntimeModuleAuthoringDataProviderDescriptors, resolvePhiRuntimeModuleSet, } from "../../../plugins/runtime-modules/resolver";
+import { PhiRuntimeModuleAuthoringDataProviderHost } from "../../../components/runtime/runtime-module-authoring-host";
+import { PhiRuntimeModuleDataProviderClientHost } from "../../../components/runtime/runtime-module-data-provider-client-manifest";
+import { resolvePhiBuilderAuthoringPickerDataProviderKeysFromCatalog } from "./authoring-provider-keys";
+import { readPhiServerApiCredentials } from "../../../helpers/phis-server-credentials";
+export async function PhiBuilderInspectorSectionWidget({ runtime, registry, view, section, signalRoutes, }) {
+    const area = normalizePhiBuilderAreaSearchParam(runtime.request?.searchParams?.[PHI_BUILDER_AREA_SEARCH_PARAM]) ?? "public";
+    const moduleIds = await buildPhiBuilderRuntimeModuleIdsForArea(runtime, area, registry.runtimeModuleCatalog);
+    const moduleSet = await resolvePhiRuntimeModuleSet({
+        catalog: registry.runtimeModuleCatalog,
+        area: resolvePhiBuilderAreaAsCmsArea(area),
+        moduleIds,
+        serverCapabilities: registry.serverCapabilities,
+    });
+    const builderModuleSet = await resolvePhiRuntimeModuleSet({
+        catalog: registry.runtimeModuleCatalog,
+        area: "builder",
+        serverCapabilities: registry.serverCapabilities,
+    });
+    const targetDataProviderDescriptors = resolvePhiRuntimeModuleAuthoringDataProviderDescriptors({ moduleSet });
+    const builderDataProviderDescriptors = resolvePhiRuntimeModuleAuthoringDataProviderDescriptors({ moduleSet: builderModuleSet });
+    const authoringDataProviderKeys = [
+        ...new Set([
+            ...builderDataProviderDescriptors.map((descriptor) => descriptor.key),
+            ...targetDataProviderDescriptors.map((descriptor) => descriptor.key),
+        ]),
+    ];
+    const [backgroundLabels, borderLabels, geometryLabels, signalsLabels, colorPickerLabels,] = await Promise.all([
+        getPhiBackgroundWidgetLabels({
+            apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl,
+            internalToken: readPhiServerApiCredentials().internalToken,
+            locale: runtime.locale.current,
+        }),
+        getPhiBorderWidgetLabels({
+            apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl,
+            internalToken: readPhiServerApiCredentials().internalToken,
+            locale: runtime.locale.current,
+        }),
+        getPhiGeometryWidgetLabels({
+            apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl,
+            internalToken: readPhiServerApiCredentials().internalToken,
+            locale: runtime.locale.current,
+        }),
+        getPhiSignalsWidgetLabels({
+            apiBaseUrl: readPhiServerApiCredentials().apiBaseUrl,
+            internalToken: readPhiServerApiCredentials().internalToken,
+            locale: runtime.locale.current,
+        }),
+        getPhiColorPickerLabelsForRuntime(runtime),
+    ]);
+    return (_jsx(PhiRuntimeModuleAuthoringDataProviderHost, { providerKeys: authoringDataProviderKeys, children: _jsx(PhiRuntimeModuleDataProviderClientHost, { providerKeys: resolvePhiBuilderAuthoringPickerDataProviderKeysFromCatalog(registry.runtimeModuleCatalog), mode: "live", children: view === "region" ? (_jsx(PhiBuilderRegionInspectorSectionWidgetClient, { section: section, signalRoutes: signalRoutes, geometryLabels: geometryLabels, backgroundLabels: backgroundLabels, borderLabels: borderLabels, colorPickerLabels: colorPickerLabels })) : view === "layout" ? (_jsx(PhiBuilderLayoutInspectorSectionWidgetClient, { section: section, signalRoutes: signalRoutes, signalsLabels: signalsLabels, backgroundLabels: backgroundLabels, borderLabels: borderLabels, colorPickerLabels: colorPickerLabels })) : (_jsx(PhiBuilderWidgetInspectorSectionWidgetClient, { section: section, signalRoutes: signalRoutes, geometryLabels: geometryLabels, signalsLabels: signalsLabels, colorPickerLabels: colorPickerLabels })) }) }));
+}

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

@@ -0,0 +1,2 @@
+import type { PhiRuntimeModuleLayoutDefinition } from "../contracts";
+export declare const PHI_BUILDER_RUNTIME_MODULE_LAYOUTS: readonly PhiRuntimeModuleLayoutDefinition[];

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

@@ -0,0 +1,21 @@
+import { PHI_PAGE_REGION_LAYOUT_DEFINITION, PHI_STRUCTURE_REGION_LAYOUT_DEFINITION, } from "../../../components/layouts/layout-definitions";
+import { PHI_BUILDER_RUNTIME_MODULE_ID } from "./ids";
+const RENDER_POLICIES = {
+    runtime: "custom",
+    preview: "runtimeReadOnly",
+    authoring: "custom",
+};
+function defineBuilderLayout(definition, load) {
+    return {
+        ownerModuleId: PHI_BUILDER_RUNTIME_MODULE_ID,
+        definition: definition,
+        renderPolicies: RENDER_POLICIES,
+        loadRuntime: load,
+    };
+}
+export const PHI_BUILDER_RUNTIME_MODULE_LAYOUTS = [
+    defineBuilderLayout(PHI_STRUCTURE_REGION_LAYOUT_DEFINITION, () => import("../../../components/layouts/plugins/structure-region-layout-plugin")
+        .then((module) => module.PHI_STRUCTURE_REGION_LAYOUT_PLUGIN)),
+    defineBuilderLayout(PHI_PAGE_REGION_LAYOUT_DEFINITION, () => import("../../../components/layouts/plugins/page-region-layout-plugin")
+        .then((module) => module.PHI_PAGE_REGION_LAYOUT_PLUGIN)),
+];

package/plugins/runtime-modules/builder/module-authoring-catalog.d.ts

@@ -0,0 +1,16 @@
+import type { PhiCalendarAdapterDescriptor } from "../../../types/calendar";
+import type { PhiRuntimeModuleClientWidgetDefinition, PhiRuntimeModuleDataProviderDescriptor, PhiRuntimeModuleId } from "../../../types/cms-plugins";
+import type { PhiRuntimeDataProviderKey } from "../../../types/runtime-data-provider";
+import type { PhiControlOption } from "../../../components/controls/phi-control-options";
+import type { PhiBuilderPluginMeta } from "../../../types/builder";
+export type PhiBuilderModuleAuthoringCatalogEntry = {
+    moduleId: PhiRuntimeModuleId;
+    locked: boolean;
+    plugins: readonly PhiBuilderPluginMeta[];
+    widgetDefinitions: readonly PhiRuntimeModuleClientWidgetDefinition[];
+    layoutTypes: readonly string[];
+    dataProviderDescriptors: readonly PhiRuntimeModuleDataProviderDescriptor[];
+    calendarAdapterDescriptors: readonly PhiCalendarAdapterDescriptor[];
+    formOptions: readonly PhiControlOption[];
+    authoringDataProviderKeys: readonly PhiRuntimeDataProviderKey[];
+};

package/plugins/runtime-modules/builder/module-authoring-catalog.js

@@ -0,0 +1 @@
+export {};

package/plugins/runtime-modules/builder/module-authoring-catalog.server.d.ts

@@ -0,0 +1,11 @@
+import "server-only";
+import type { PhiAccessViewer } from "../../../types/access";
+import type { PhiRuntimeModuleCatalog, PhiRuntimeModuleId } from "../../../types";
+import type { PhiDeveloperBuilderArea } from "./developer-workspace-types";
+import type { PhiBuilderModuleAuthoringCatalogEntry } from "./module-authoring-catalog";
+export declare function buildPhiBuilderModuleAuthoringCatalog({ catalog, area, activeModuleIds, viewer, }: {
+    catalog: PhiRuntimeModuleCatalog;
+    area: PhiDeveloperBuilderArea;
+    activeModuleIds: ReadonlySet<PhiRuntimeModuleId>;
+    viewer: PhiAccessViewer;
+}): PhiBuilderModuleAuthoringCatalogEntry[];

package/plugins/runtime-modules/builder/module-authoring-catalog.server.js

@@ -0,0 +1,54 @@
+import "server-only";
+import { canPhiViewerAccessOwnedPolicy } from "../../../types/access";
+import { buildPhiRuntimeModuleLayoutType, buildPhiRuntimeModuleWidgetType, } from "../../../plugins/runtime-modules/contracts";
+import { buildPhiBuilderLayoutPluginMetas, buildPhiBuilderPluginMeta, } from "./plugin-metas";
+export function buildPhiBuilderModuleAuthoringCatalog({ catalog, area, activeModuleIds, viewer, }) {
+    const areaDefinition = catalog.areaDefinitions.find((definition) => definition.area === area);
+    if (!areaDefinition) {
+        throw new Error(`Area "${area}" is not declared in the runtime module catalog.`);
+    }
+    const platformModuleId = catalog.platformModuleId;
+    if (!platformModuleId) {
+        throw new Error("Runtime module catalog has no Platform contribution.");
+    }
+    const lockedModuleIds = new Set([
+        platformModuleId,
+        areaDefinition.baseModuleId,
+    ]);
+    return [...catalog.entries()].flatMap(([moduleId, entry]) => {
+        const locked = lockedModuleIds.has(moduleId);
+        if (!activeModuleIds.has(moduleId)) {
+            return [];
+        }
+        const providerId = entry.definition.serverBinding.providerId;
+        const widgets = entry.widgets.filter((widget) => canPhiViewerAccessOwnedPolicy(viewer, widget.accessPolicy, providerId));
+        const layouts = entry.layouts.filter((layout) => canPhiViewerAccessOwnedPolicy(viewer, layout.accessPolicy, providerId));
+        return [{
+                moduleId,
+                locked,
+                plugins: [
+                    ...layouts.flatMap((layout) => buildPhiBuilderLayoutPluginMetas(layout.definition)),
+                    ...widgets.map((widget) => buildPhiBuilderPluginMeta(widget.definition)),
+                ],
+                widgetDefinitions: widgets.map((widget) => ({
+                    type: buildPhiRuntimeModuleWidgetType(widget),
+                    ownerModuleId: widget.ownerModuleId,
+                    title: widget.definition.title,
+                    signalSubcontrols: widget.definition.signalSubcontrols,
+                    slotSizePolicy: widget.definition.slotSizePolicy,
+                    renderPolicies: widget.renderPolicies,
+                })),
+                layoutTypes: layouts.map(buildPhiRuntimeModuleLayoutType),
+                dataProviderDescriptors: entry.definition.dataProviders ?? [],
+                calendarAdapterDescriptors: entry.definition.calendarAdapters ?? [],
+                formOptions: (entry.forms ?? []).map((form) => ({
+                    value: form.formId,
+                    label: form.title,
+                    description: form.description ?? undefined,
+                })),
+                authoringDataProviderKeys: (entry.definition.dataProviders ?? [])
+                    .filter((descriptor) => descriptor.authoringMode !== "none")
+                    .map((descriptor) => descriptor.key),
+            }];
+    });
+}

package/plugins/runtime-modules/builder/module-usage-client.d.ts

@@ -0,0 +1,17 @@
+import type { PhiBuilderPageCatalogArea } from "../../../helpers/cms-page-catalog";
+/**
+ * What a Module draws on this Site's published pages, per Area.
+ *
+ * Asked when a Module is about to be switched off. The blocks are not deleted by that -- they stay in
+ * their pages and stop being drawn -- but a page losing a third of its content without anyone saying
+ * so is exactly the kind of quiet damage the Builder exists to prevent.
+ */
+export type PhiBuilderModuleBlockUsageEntry = {
+    kind: "page" | "area";
+    pageScopeId: number | null;
+    path: string | null;
+    ownerModuleId: string | null;
+    presetKey: string | null;
+    blocks: number;
+};
+export declare function loadPhiBuilderModuleBlockUsage(area: PhiBuilderPageCatalogArea, moduleId: string): Promise<PhiBuilderModuleBlockUsageEntry[]>;

package/plugins/runtime-modules/builder/module-usage-client.js

@@ -0,0 +1,17 @@
+"use client";
+import { resolvePhiBuilderCatalogApiArea } from "../../../helpers/cms-page-catalog";
+export async function loadPhiBuilderModuleBlockUsage(area, moduleId) {
+    const url = new URL("/api/site/cms/module-usage", window.location.origin);
+    url.searchParams.set("area", resolvePhiBuilderCatalogApiArea(area));
+    url.searchParams.set("moduleId", moduleId);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        cache: "no-store",
+        credentials: "same-origin",
+    });
+    const body = (await response.json().catch(() => null));
+    if (!response.ok) {
+        throw new Error(body?.error ?? "Failed to read Module usage.");
+    }
+    return Array.isArray(body?.usage) ? body.usage : [];
+}