@phis/ui 0.1.0 → 0.2.0

package/plugins/runtime/slot-size-policy.d.ts

@@ -1,5 +1,6 @@
 import { type CSSProperties, type ReactNode } from "react";
-import type { PhiRenderableBlockBase, PhiSlotAxisSizePolicy, PhiSlotSizePolicy, PhiNormalizedSlotSizePolicy } from "../../types";
+import type { PhiSlotAxisSizePolicy, PhiSlotSizePolicy, PhiNormalizedSlotSizePolicy } from "../../types";
+import { type PhiRenderableBlockGeometryInput, type PhiResolvedBlockGeometry, type PhiResolvedBlockLength } from "../../types/renderable-block-geometry";
 export type PhiSlotChildKind = "widget" | "layout";
 export type PhiSlotChildSizing = {
     policy: PhiNormalizedSlotSizePolicy;
@@ -11,10 +12,38 @@ export type PhiSlotChildSizing = {
     maxBlockSize?: CSSProperties["maxHeight"];
 };
 export declare function resolvePhiSlotSizePolicy(policy: PhiSlotSizePolicy | null | undefined, kind: PhiSlotChildKind): PhiNormalizedSlotSizePolicy;
-export declare function resolvePhiSlotChildExplicitAxes(config: Pick<PhiRenderableBlockBase, "size"> | null | undefined): {
+export declare function resolvePhiSlotChildExplicitAxes(geometry: PhiResolvedBlockGeometry): {
     explicitInlineSize: boolean;
     explicitBlockSize: boolean;
 };
+/**
+ * The policy a child actually runs on, which is not always the one it declared.
+ *
+ * An axis that states a size of its own is fixed on that axis, whatever the policy said. A Layout's
+ * declared policy is fill on both axes and a width used to be recorded beside it without changing it:
+ * the child then claimed the whole axis while measuring something else, so the slot stretched, and a
+ * Layout with an anchor had nothing left to place. Every caller had to remember to subtract the one
+ * from the other, and the callers that forgot were the bugs.
+ *
+ * A maximum is deliberately not a size. `maxWidth` means "fill, but no further than this" -- a column
+ * of copy at a readable measure still wants the width it is given, up to the cap. It stays filling and
+ * is merely capped; what it needs is not a different policy but a Layout that places it rather than
+ * stretching it, which is the anchor's job.
+ *
+ * Applied where the sizing is resolved rather than offered as something to call, because a size can
+ * also arrive at runtime -- a Signal that sets a width has to flip the policy the same way a stored
+ * config does, and a rule that has to be remembered at each site is a rule that is already broken.
+ */
+export declare function resolvePhiEffectiveSlotSizePolicy(policy: PhiNormalizedSlotSizePolicy, explicit: {
+    explicitInlineSize?: boolean;
+    explicitBlockSize?: boolean;
+} | null | undefined): PhiNormalizedSlotSizePolicy;
+export declare function resolvePhiSlotChildSizeConstraints(geometry: PhiResolvedBlockGeometry): {
+    minInlineSize: string | undefined;
+    minBlockSize: string | undefined;
+    maxInlineSize: string | undefined;
+    maxBlockSize: string | undefined;
+};
 /**
  * The sizing a client-enhanced slot child hands to the parent layout, resolved rather than referred.
  *
@@ -28,7 +57,7 @@ export declare function resolvePhiSlotChildExplicitAxes(config: Pick<PhiRenderab
  *
  * Six resolved values carry the same information and share nothing, so there is no reference to fill in.
  */
-export declare function resolvePhiSlotChildSizingForConfig(kind: PhiSlotChildKind, slotSizePolicy: PhiSlotSizePolicy | null | undefined, config: Pick<PhiRenderableBlockBase, "size" | "minSize" | "maxSize"> | null | undefined): PhiSlotChildSizing;
+export declare function resolvePhiSlotChildSizingForConfig(kind: PhiSlotChildKind, slotSizePolicy: PhiSlotSizePolicy | null | undefined, config: PhiRenderableBlockGeometryInput | null | undefined): PhiSlotChildSizing;
 export declare function buildPhiSlotChildClassName(policy: PhiNormalizedSlotSizePolicy): string;
 export declare function buildPhiSlotChildDataAttributes(policy: PhiNormalizedSlotSizePolicy, options?: {
     explicitInlineSize?: boolean;
@@ -50,3 +79,5 @@ export declare function buildPhiSlotChildDataAttributes(policy: PhiNormalizedSlo
 };
 export declare function resolvePhiSlotChildSizing(child: ReactNode, fallbackKind?: PhiSlotChildKind): PhiSlotChildSizing;
 export declare function resolvePhiSlotChildBaseStyle(policy: PhiNormalizedSlotSizePolicy): CSSProperties;
+export declare function resolvePhiSlotChildInlineMaximum(max: PhiResolvedBlockLength | null, inlinePolicy: PhiSlotAxisSizePolicy): string | undefined;
+export declare function resolvePhiSlotChildSizeStyle(geometry: PhiResolvedBlockGeometry, policy: PhiNormalizedSlotSizePolicy): CSSProperties;

package/plugins/runtime/slot-size-policy.js

@@ -1,4 +1,16 @@
 import { isValidElement } from "react";
+import { PHI_SLOT_BLOCK_PLACEMENT_MARGIN_STYLE, PHI_SLOT_INLINE_PLACEMENT_MARGIN_STYLE, } from "../../components/layouts/phi-layout-contract";
+import { resolvePhiRenderableBlockGeometry, } from "../../types/renderable-block-geometry";
+/*
+ * What a child sizes like when nothing says otherwise.
+ *
+ * Every Widget and Layout definition states its own policy (`slotSizePolicy` is required there), so this
+ * is no longer the answer any of them relies on. What is left for it: a policy that arrives from a config
+ * rather than from a definition and is absent, and an object form that names one axis and leaves the
+ * other open. The two entries stay apart because the open axis of a Layout and of a Widget do want
+ * different answers -- a Layout has no size of its own and takes the room it is given, a Widget is its
+ * content until it says otherwise.
+ */
 const PHI_SLOT_CHILD_DEFAULT_POLICY = {
     widget: {
         inline: "intrinsic",
@@ -14,9 +26,23 @@ function normalizePhiSlotPolicyAxis(axis, fallback) {
 }
 export function resolvePhiSlotSizePolicy(policy, kind) {
     const fallback = PHI_SLOT_CHILD_DEFAULT_POLICY[kind];
-    if (policy == null || policy === "intrinsic") {
+    if (policy == null) {
         return fallback;
     }
+    /*
+     * Stated `intrinsic` means intrinsic, on both axes, for a Layout as much as for a Widget.
+     *
+     * It used to fall through to the kind's default, which for a Widget happens to be the same answer and
+     * for a Layout is the opposite one: a Layout asking to be its content would have filled its slot. No
+     * Layout asked, so nothing moved -- but the word has to mean what it says now that every definition
+     * has to say it.
+     */
+    if (policy === "intrinsic") {
+        return {
+            inline: "intrinsic",
+            block: "intrinsic",
+        };
+    }
     if (policy === "fill") {
         return {
             inline: "fill",
@@ -46,18 +72,41 @@ export function resolvePhiSlotSizePolicy(policy, kind) {
         block: normalizePhiSlotPolicyAxis(policy.block, fallback.block),
     };
 }
-export function resolvePhiSlotChildExplicitAxes(config) {
+export function resolvePhiSlotChildExplicitAxes(geometry) {
     return {
-        explicitInlineSize: config?.size?.width != null,
-        explicitBlockSize: config?.size?.height != null,
+        explicitInlineSize: geometry.explicitInline,
+        explicitBlockSize: geometry.explicitBlock,
     };
 }
-function resolvePhiSlotChildSizeConstraints(config) {
+/**
+ * The policy a child actually runs on, which is not always the one it declared.
+ *
+ * An axis that states a size of its own is fixed on that axis, whatever the policy said. A Layout's
+ * declared policy is fill on both axes and a width used to be recorded beside it without changing it:
+ * the child then claimed the whole axis while measuring something else, so the slot stretched, and a
+ * Layout with an anchor had nothing left to place. Every caller had to remember to subtract the one
+ * from the other, and the callers that forgot were the bugs.
+ *
+ * A maximum is deliberately not a size. `maxWidth` means "fill, but no further than this" -- a column
+ * of copy at a readable measure still wants the width it is given, up to the cap. It stays filling and
+ * is merely capped; what it needs is not a different policy but a Layout that places it rather than
+ * stretching it, which is the anchor's job.
+ *
+ * Applied where the sizing is resolved rather than offered as something to call, because a size can
+ * also arrive at runtime -- a Signal that sets a width has to flip the policy the same way a stored
+ * config does, and a rule that has to be remembered at each site is a rule that is already broken.
+ */
+export function resolvePhiEffectiveSlotSizePolicy(policy, explicit) {
+    const inline = explicit?.explicitInlineSize === true ? "fixed" : policy.inline;
+    const block = explicit?.explicitBlockSize === true ? "fixed" : policy.block;
+    return inline === policy.inline && block === policy.block ? policy : { inline, block };
+}
+export function resolvePhiSlotChildSizeConstraints(geometry) {
     return {
-        minInlineSize: config?.minSize?.width ?? undefined,
-        minBlockSize: config?.minSize?.height ?? undefined,
-        maxInlineSize: config?.maxSize?.width ?? undefined,
-        maxBlockSize: config?.maxSize?.height ?? undefined,
+        minInlineSize: geometry.inline.min?.css,
+        minBlockSize: geometry.block.min?.css,
+        maxInlineSize: geometry.inline.max?.css,
+        maxBlockSize: geometry.block.max?.css,
     };
 }
 /**
@@ -74,10 +123,12 @@ function resolvePhiSlotChildSizeConstraints(config) {
  * Six resolved values carry the same information and share nothing, so there is no reference to fill in.
  */
 export function resolvePhiSlotChildSizingForConfig(kind, slotSizePolicy, config) {
+    const geometry = resolvePhiRenderableBlockGeometry(config);
+    const explicit = resolvePhiSlotChildExplicitAxes(geometry);
     return {
-        policy: resolvePhiSlotSizePolicy(slotSizePolicy, kind),
-        ...resolvePhiSlotChildExplicitAxes(config),
-        ...resolvePhiSlotChildSizeConstraints(config),
+        policy: resolvePhiEffectiveSlotSizePolicy(resolvePhiSlotSizePolicy(slotSizePolicy, kind), explicit),
+        ...explicit,
+        ...resolvePhiSlotChildSizeConstraints(geometry),
     };
 }
 export function buildPhiSlotChildClassName(policy) {
@@ -118,15 +169,18 @@ export function resolvePhiSlotChildSizing(child, fallbackKind = "widget") {
     if (sizingProps?.policy) {
         return sizingProps;
     }
-    const configConstraints = resolvePhiSlotChildSizeConstraints(props.config);
+    const configConstraints = resolvePhiSlotChildSizeConstraints(resolvePhiRenderableBlockGeometry(props.config));
     if (props.slotSizePolicy != null || props.kind != null) {
         const resolvedKind = props.kind === "widget" || props.kind === "layout"
             ? props.kind
             : fallbackKind;
-        return {
-            policy: resolvePhiSlotSizePolicy(props.slotSizePolicy, resolvedKind),
+        const explicit = {
             explicitInlineSize: props.explicitInlineSize === true || props["data-phi-layout-explicit-width"] === "true",
             explicitBlockSize: props.explicitBlockSize === true || props["data-phi-layout-explicit-height"] === "true",
+        };
+        return {
+            policy: resolvePhiEffectiveSlotSizePolicy(resolvePhiSlotSizePolicy(props.slotSizePolicy, resolvedKind), explicit),
+            ...explicit,
             ...configConstraints,
         };
     }
@@ -142,10 +196,14 @@ export function resolvePhiSlotChildSizing(child, fallbackKind = "widget") {
             ? props["data-phi-slot-size-block"]
             : undefined,
     }, fallbackKind);
-    return {
-        policy,
+    const explicit = {
         explicitInlineSize: props["data-phi-layout-explicit-width"] === "true",
         explicitBlockSize: props["data-phi-layout-explicit-height"] === "true",
+    };
+    return {
+        // Idempotent: an element that already wrote the effective policy into its attributes says the same again.
+        policy: resolvePhiEffectiveSlotSizePolicy(policy, explicit),
+        ...explicit,
         minInlineSize: configConstraints.minInlineSize ??
             (typeof props["data-phi-slot-min-inline-size"] === "string"
                 ? props["data-phi-slot-min-inline-size"]
@@ -170,7 +228,84 @@ export function resolvePhiSlotChildBaseStyle(policy) {
         minHeight: 0,
         maxWidth: "100%",
         maxHeight: "100%",
+        /*
+         * Whatever the Layout says, which is what an anchor is.
+         *
+         * A child is a flex item, and a stylesheet that stretches it takes the decision away from the
+         * Layout holding it: a stretched item is placed at the start of the cross axis, and a child that
+         * caps its own width -- a column at a readable measure -- then sits in the corner of a Layout
+         * anchored to the centre, looking as though the anchor did nothing. Stated here, and `auto` rather
+         * than a value, so it still stretches wherever the Layout asks for stretch, which is what a Layout
+         * with no anchor asks for.
+         */
+        alignSelf: "auto",
+        /*
+         * And where a Layout stretched this child in order to give it a width, this is how it is still
+         * placed: the slot hands down `--phi-slot-inline-margin`, which is `auto` on the side the anchor
+         * pulls towards and `0` everywhere else. A child that fills edge to edge has no room to be moved
+         * in and the auto margins come to nothing; a child that caps itself has, and lands where it was
+         * asked to. `0` by default, so a child whose slot says nothing keeps the margins it always had.
+         *
+         * Both axes, because a row that caps a child's height and anchors it to the bottom has the same
+         * room left over as a column that caps its width. The properties were named `cross` while they
+         * only ever wrote `margin-inline`, and under that name the missing half went unnoticed.
+         *
+         * Two longhands per axis rather than the `marginInline` shorthand: React writes a shorthand out as
+         * two longhands on the server and keeps it whole in the browser, and the two trees then disagree on
+         * an attribute React will not patch up.
+         */
+        ...PHI_SLOT_INLINE_PLACEMENT_MARGIN_STYLE,
+        ...PHI_SLOT_BLOCK_PLACEMENT_MARGIN_STYLE,
         ...(policy.inline === "fill" ? { width: "100%" } : policy.inline === "intrinsic" ? { width: "fit-content" } : {}),
         ...(policy.block === "fill" ? { height: "100%" } : policy.block === "intrinsic" ? { height: "fit-content" } : {}),
     };
 }
+/*
+ * A stated inline maximum, capped at the slot where the slot is a room.
+ *
+ * A maximum in a length that measures something other than the slot -- `px`, `em`, `rem`, `vw`, `vh` --
+ * can state more room than there is, and `min(100%, ...)` lets the room win. A `%` maximum is already
+ * measured against the slot, and an expression the vocabulary does not decode may carry its own
+ * percentage; both are written plain.
+ *
+ * The cap is left off an `intrinsic` child, because there the `100%` is the thing that breaks it. Such a
+ * child is `width: fit-content` and frequently stands in a box that shrinks to fit it -- the anchored
+ * Overlay, a centred slot -- so the percentage is measured against a width that is being computed from
+ * this element. A plain cyclic percentage merely behaves as `none`, but one inside a math function
+ * cannot, so the browser drops the declaration whole and the stated maximum with it. That was the
+ * Markdown Widget's finding: a stated maximum width that nothing honoured. Plain, the maximum holds, and
+ * nothing overflows for the missing cap -- `fit-content` does not exceed the room it is offered.
+ *
+ * What the frame still cannot see is its parent: a `fixed` child inside a shrink-to-fit box meets the
+ * same cyclic percentage, and the frame has no way to know it is in one. Its stated width wins there,
+ * as it did before.
+ */
+const PHI_SLOT_CHILD_CAPPED_MAX_UNITS = ["px", "em", "rem", "vw", "vh"];
+export function resolvePhiSlotChildInlineMaximum(max, inlinePolicy) {
+    if (max == null) {
+        return undefined;
+    }
+    const capped = inlinePolicy !== "intrinsic" &&
+        max.part != null &&
+        PHI_SLOT_CHILD_CAPPED_MAX_UNITS.includes(max.part.unit);
+    return capped ? `min(100%, ${max.css})` : max.css;
+}
+/*
+ * The frame's own box, from the geometry read once.
+ *
+ * The block axis takes no cap, which is the inline rule read the other way round: a percentage height is
+ * measured against a containing block whose height is `auto` in the ordinary case, so `min(100%, ...)`
+ * there would meet the cyclic percentage as the rule rather than as the exception. A stated block
+ * maximum is written as it stands.
+ */
+export function resolvePhiSlotChildSizeStyle(geometry, policy) {
+    const maxWidth = resolvePhiSlotChildInlineMaximum(geometry.inline.max, policy.inline);
+    return {
+        ...(geometry.inline.size == null ? {} : { width: geometry.inline.size.css }),
+        ...(geometry.block.size == null ? {} : { height: geometry.block.size.css }),
+        ...(geometry.inline.min == null ? {} : { minWidth: geometry.inline.min.css }),
+        ...(geometry.block.min == null ? {} : { minHeight: geometry.block.min.css }),
+        ...(maxWidth == null ? {} : { maxWidth }),
+        ...(geometry.block.max == null ? {} : { maxHeight: geometry.block.max.css }),
+    };
+}

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

@@ -2,12 +2,9 @@ export declare const PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION: Omit<{
     area: "accounting";
     moduleId: "@phis/ui/modules/accounting";
     serverBinding: import("../../../types").PhiRuntimeModuleServerBinding;
-    controllerType: "@phis/ui/modules/accounting/controller/base";
-    controller: import("../contracts").PhiRuntimeModuleControllerDescriptor;
     description: string;
     category: "foundation";
     icon: string;
-    controllerMountPolicy: "area";
 }, "area"> & {
     kind: "module";
     eligibleAreas: readonly ["public" | "app" | "admin" | "builder" | "editor" | "accounting"];

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

@@ -1,6 +1,3 @@
-import { PHI_ACCOUNTING_BASE_CONTROLLER_DEFINITION, } from "../../../components/runtime/area-base-controller-definitions";
-import { PHI_ACCOUNTING_BASE_CONTROLLER_TYPE, } from "../../../components/runtime/area-base-controller-addresses";
-import { buildPhiRuntimeModuleControllerDescriptor } from "../contracts";
 import { definePhiAreaBaseRuntimeModuleDefinition } from "../area-base-definition";
 import { PHI_ACCOUNTING_RUNTIME_MODULE_ID } from "./ids";
 import { PHI_CORE_SERVER_BINDING, } from "../../../types/server-capabilities";
@@ -8,10 +5,7 @@ export const PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION = definePhiAreaBaseRuntime
     area: "accounting",
     moduleId: PHI_ACCOUNTING_RUNTIME_MODULE_ID,
     serverBinding: PHI_CORE_SERVER_BINDING,
-    controllerType: PHI_ACCOUNTING_BASE_CONTROLLER_TYPE,
-    controller: buildPhiRuntimeModuleControllerDescriptor(PHI_ACCOUNTING_BASE_CONTROLLER_DEFINITION),
     description: "Locked Accounting Area shell, navigation surface, and accounting workspace route.",
     category: "foundation",
     icon: "antd:profile",
-    controllerMountPolicy: "area",
 });

package/plugins/runtime-modules/accounting/module.d.ts

@@ -1 +1,15 @@
-export declare const PHI_ACCOUNTING_RUNTIME_MODULE: import("../contracts").PhiRuntimeModule;
+/**
+ * No Controller. The Area base Controller this Module carried answered nothing and rendered nothing,
+ * and was mounted on every page of the Area for it. Area-wide behaviour that belongs to no Module goes
+ * to the Core Runtime Controller; a Module's own goes into that Module's Controller, mounted on demand.
+ */
+export declare const PHI_ACCOUNTING_RUNTIME_MODULE: {
+    description: string;
+    icon: string;
+    category: "foundation";
+    moduleId: "@phis/ui/modules/accounting";
+    serverBinding: import("../../../types").PhiRuntimeModuleServerBinding;
+    kind: "module";
+    eligibleAreas: readonly ["public" | "app" | "admin" | "builder" | "editor" | "accounting"];
+    title: "Public Base" | "App Base" | "Accounting Base" | "Admin Base" | "Builder Base" | "Editor Base";
+};

package/plugins/runtime-modules/accounting/module.js

@@ -1,4 +1,9 @@
-import { PHI_ACCOUNTING_BASE_CONTROLLER_DEFINITION } from "../../../components/runtime/area-base-controller-definitions";
 import { PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION } from "../accounting/definition";
-import { createPhiAreaBaseRuntimeModule } from "../area-base-module";
-export const PHI_ACCOUNTING_RUNTIME_MODULE = createPhiAreaBaseRuntimeModule(PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION, PHI_ACCOUNTING_BASE_CONTROLLER_DEFINITION);
+/**
+ * No Controller. The Area base Controller this Module carried answered nothing and rendered nothing,
+ * and was mounted on every page of the Area for it. Area-wide behaviour that belongs to no Module goes
+ * to the Core Runtime Controller; a Module's own goes into that Module's Controller, mounted on demand.
+ */
+export const PHI_ACCOUNTING_RUNTIME_MODULE = {
+    ...PHI_ACCOUNTING_RUNTIME_MODULE_DEFINITION,
+};

package/plugins/runtime-modules/accounting/trees/phi-default-accounting-page-tree.d.ts

@@ -0,0 +1,6 @@
+import type { PhiResolvedCmsPageTree, PhiCmsPageNode } from "../../../../types/cms";
+import type { PhiBlockRuntime } from "../../../../types";
+export declare function buildPhiDefaultAccountingPageTree({ page, }: {
+    page: PhiCmsPageNode;
+    runtime: PhiBlockRuntime;
+}): Promise<PhiResolvedCmsPageTree>;

package/plugins/runtime-modules/accounting/trees/phi-default-accounting-page-tree.js

@@ -0,0 +1,45 @@
+import { createPhiPresetCmsInstanceIdMap } from "../../../../types/cms-instance-id";
+import { PHI_ACCOUNTING_RUNTIME_MODULE_ID } from "../ids";
+import { PHI_CMS_SEQUENTIAL_LAYOUT_SLOTS } from "../../../../constants/cms-layout-types";
+import { PhiCmsPageType } from "../../../../constants/phi-cms";
+import { createPhiCmsPresetNodes } from "../../../../helpers/cms-preset-nodes";
+import { buildPhiBasePageContentScaffold, PHI_BASE_PAGE_LAYOUT_NODE_ID } from "../../../../components/regions/presets/phi-base-page-layout";
+const SYNTHETIC_ACCOUNTING_REGION_IDS = {
+    regionContent: -451,
+};
+const SYNTHETIC_ACCOUNTING_WIDGET_IDS = createPhiPresetCmsInstanceIdMap({
+    domain: "page",
+    ownerModuleId: PHI_ACCOUNTING_RUNTIME_MODULE_ID,
+    presetKey: "accounting-overview-page",
+}, [
+    "widgetOverview",
+]);
+export async function buildPhiDefaultAccountingPageTree({ page, }) {
+    const scaffold = buildPhiBasePageContentScaffold({
+        page,
+        regionId: SYNTHETIC_ACCOUNTING_REGION_IDS.regionContent,
+    });
+    const nodes = createPhiCmsPresetNodes(page);
+    return {
+        page: nodes.page({ pageType: PhiCmsPageType.Standard }),
+        overlays: [],
+        regions: [scaffold.region],
+        layoutNodes: [scaffold.layoutNode],
+        contentWidgets: [
+            nodes.widget({
+                id: SYNTHETIC_ACCOUNTING_WIDGET_IDS.widgetOverview,
+                parentLayoutNodeId: PHI_BASE_PAGE_LAYOUT_NODE_ID,
+                typeKey: "card",
+                slotIndex: PHI_CMS_SEQUENTIAL_LAYOUT_SLOTS[0].slotIndex,
+                sortOrder: 0,
+                label: "Accounting",
+                config: {
+                    eyebrow: "Accounting",
+                    title: "Accounting",
+                    description: "Invoices and billing workflows for this site.",
+                    variant: "compact",
+                },
+            }),
+        ],
+    };
+}

package/plugins/runtime-modules/admin/controller/address.d.ts

@@ -1,5 +1,3 @@
 export declare const PHI_ADMIN_CONTROLLER_PLUGIN_KEY = "@phis/ui/modules/admin/controller";
 export declare const PHI_ADMIN_CONTROLLER_KEY = "default";
 export declare const PHI_ADMIN_CONTROLLER_TYPE: "@phis/ui/modules/admin/controller/default";
-export declare const PHI_ADMIN_CONTROLLER_INSTANCE_KEY = "default";
-export declare function createPhiAdminControllerAddress(): `controller:${string}/${string}:${string}`;

package/plugins/runtime-modules/admin/controller/address.js

@@ -1,8 +1,4 @@
-import { PHI_SHARED_PACKAGE_NAME, createPhiControllerSignalAddress } from "../../../../types/signals";
+import { PHI_SHARED_PACKAGE_NAME } from "../../../../types/signals";
 export const PHI_ADMIN_CONTROLLER_PLUGIN_KEY = `${PHI_SHARED_PACKAGE_NAME}/modules/admin/controller`;
 export const PHI_ADMIN_CONTROLLER_KEY = "default";
 export const PHI_ADMIN_CONTROLLER_TYPE = `${PHI_ADMIN_CONTROLLER_PLUGIN_KEY}/${PHI_ADMIN_CONTROLLER_KEY}`;
-export const PHI_ADMIN_CONTROLLER_INSTANCE_KEY = "default";
-export function createPhiAdminControllerAddress() {
-    return createPhiControllerSignalAddress(PHI_ADMIN_CONTROLLER_PLUGIN_KEY, PHI_ADMIN_CONTROLLER_KEY, PHI_ADMIN_CONTROLLER_INSTANCE_KEY);
-}

package/plugins/runtime-modules/admin/forms.js

@@ -85,6 +85,7 @@ async function loadLabels(context) {
         supportEmail: labels.fields.supportEmail,
         supportEmailRequired: labels.fields.supportEmail,
         supportEmailInvalid: labels.feedback.errorInvalidSupportEmail,
+        actions: { submitLabel: labels.submitLabel },
     });
 }
 export const PHI_ADMIN_RUNTIME_MODULE_FORMS = [
@@ -100,12 +101,6 @@ export const PHI_ADMIN_RUNTIME_MODULE_FORMS = [
         tags: ["settings", "site", "admin"],
         descriptor: PHI_ADMIN_SETTINGS_GENERAL_FORM_DESCRIPTOR,
         submitHandlerKey: PHI_ADMIN_SETTINGS_FORM_HANDLER_KEYS.general,
-        confirmHandlerKey: null,
-        previewHandlerKey: null,
-        defaultConfig: {},
-        variant: "default",
-        config: {},
-        previewUpstreamPath: null,
         loadLabels,
     }),
 ];

package/plugins/runtime-modules/admin/module.d.ts

@@ -1,45 +1 @@
-export declare const PHI_ADMIN_RUNTIME_MODULE: {
-    controllerDefinition: {
-        kind: "controller";
-        pluginKey: string;
-        key: string;
-        title: string;
-        description: string;
-        iconFamily: string;
-        allowedMountScopes: "area"[];
-        runtimeSignals: {
-            emits: never[];
-            listens: never[];
-        };
-        defaultConfig: {};
-        parseConfig: () => import("../../../plugins/runtime-modules/admin/controller/definition").PhiAdminControllerConfig;
-    };
-    description: string;
-    category: "foundation";
-    iconFamily: string;
-    controller: import("../contracts").PhiRuntimeModuleControllerDescriptor;
-    moduleId: "@phis/ui/modules/admin";
-    serverBinding: import("../../../types").PhiRuntimeModuleServerBinding;
-    controllerType: "@phis/ui/modules/admin/controller/default";
-    controllerMountPolicy: "area";
-    formProviders: {
-        handlers: {
-            key: `${string}/${string}`;
-            ownerModuleId: "@phis/ui/modules/admin";
-            title: string;
-            phase: "submit";
-            handlerKey: "site.admin.settings";
-            category: "site";
-            transport: "relay";
-            method: "PATCH";
-            endpointKey: null;
-            upstreamPath: string;
-            csrfPath: null;
-            requiresCsrf: false;
-            credentialPolicy: "site-session";
-        }[];
-    };
-    kind: "module";
-    eligibleAreas: readonly ["public" | "app" | "admin" | "builder" | "editor" | "accounting"];
-    title: "Public Base" | "App Base" | "Accounting Base" | "Admin Base" | "Builder Base" | "Editor Base";
-};
+export declare const PHI_ADMIN_RUNTIME_MODULE: import("../contracts").PhiRuntimeModule;

package/plugins/runtime-modules/admin/module.js

@@ -1,6 +1,4 @@
 import { PHI_ADMIN_RUNTIME_CONTROLLER_DEFINITION } from "../../../plugins/runtime-modules/admin/controller/definition";
 import { PHI_ADMIN_RUNTIME_MODULE_DEFINITION } from "./definition";
-export const PHI_ADMIN_RUNTIME_MODULE = {
-    ...PHI_ADMIN_RUNTIME_MODULE_DEFINITION,
-    controllerDefinition: PHI_ADMIN_RUNTIME_CONTROLLER_DEFINITION,
-};
+import { createPhiAreaBaseRuntimeModule } from "../area-base-module";
+export const PHI_ADMIN_RUNTIME_MODULE = createPhiAreaBaseRuntimeModule(PHI_ADMIN_RUNTIME_MODULE_DEFINITION, PHI_ADMIN_RUNTIME_CONTROLLER_DEFINITION);

package/plugins/runtime-modules/admin/presets.d.ts

@@ -12,6 +12,7 @@ export declare const PHI_ADMIN_RUNTIME_MODULE_AREA_SHELLS: {
         layoutNodes: import("../../../types").PhiCmsLayoutNode[];
         contentWidgets: import("../../../types").PhiCmsContentWidgetNode[];
         page: import("../../../types").PhiCmsPageNode;
+        controllerSettings?: readonly import("../../../types").PhiRuntimeControllerSetting[] | null;
     }>;
 }[];
 export declare const PHI_ADMIN_RUNTIME_MODULE_ROUTES: (PhiCmsRoutePresetDescriptor | {
@@ -20,11 +21,6 @@ export declare const PHI_ADMIN_RUNTIME_MODULE_ROUTES: (PhiCmsRoutePresetDescript
     presetKey: string;
     presetVersion: number;
     title: string;
-    accessPolicy: {
-        readonly access: "roles";
-        readonly providerId: "@phis/server/core";
-        readonly allowedRoleFlags: number;
-    };
     path: string;
     mount: {
         mountKey: string;

package/plugins/runtime-modules/admin/presets.js

@@ -3,7 +3,6 @@ import { buildPhiAreaRootRoutePresetDescriptor } from "../area-root-route";
 import { PhiCmsRegionType } from "../../../constants/phi-cms";
 import { PHI_DEFAULT_PUB_AREA_COMPOSITION_NODE_KEYS, } from "../preset-contracts/pub-area";
 import { PHI_ADMIN_RUNTIME_MODULE_ID } from "./ids";
-import { PHI_VIEWER_ACCESS_DEVELOPER_TOOLS, PHI_VIEWER_ACCESS_SITE_ADMIN, } from "../../../types/access";
 export const PHI_ADMIN_RUNTIME_MODULE_AREA_SHELLS = [{
         ownerModuleId: PHI_ADMIN_RUNTIME_MODULE_ID,
         presetKey: "admin-area-preset",
@@ -11,8 +10,8 @@ export const PHI_ADMIN_RUNTIME_MODULE_AREA_SHELLS = [{
         area: "admin",
         loadTree: async ({ page, runtime }) => {
             const [{ buildPhiDefaultSiteAreaPresetTree }, { buildPhiDefaultAdminAreaPresetTree }, { mergePhiCmsShellTrees, omitPhiCmsShellCompositionNodes },] = await Promise.all([
-                import("../../../components/regions/presets/phi-default-site-area-preset-tree"),
-                import("../../../components/regions/presets/phi-default-admin-area-preset-tree"),
+                import("../phi-default-site-area-preset-tree"),
+                import("./trees/phi-default-admin-area-preset-tree"),
                 import("../shell-tree-composition"),
             ]);
             const [base, overlay] = await Promise.all([
@@ -33,10 +32,9 @@ const ADMIN_OWNED_ROUTES = [
         presetKey: "admin-settings-general-page",
         presetVersion: 1 + PHI_BASE_PAGE_LAYOUT_VERSION,
         title: "General",
-        accessPolicy: PHI_VIEWER_ACCESS_SITE_ADMIN,
         path: "/settings/general",
         mount: { mountKey: "settings" },
-        loadTree: ({ page, runtime }) => import("../../../components/regions/presets/phi-default-admin-settings-page-tree")
+        loadTree: ({ page, runtime }) => import("./trees/phi-default-admin-settings-page-tree")
             .then((module) => module.buildPhiDefaultAdminSettingsPageTree({ page, runtime })),
     },
 ].map((route) => ({
@@ -49,7 +47,6 @@ export const PHI_ADMIN_RUNTIME_MODULE_ROUTES = [
         ownerModuleId: PHI_ADMIN_RUNTIME_MODULE_ID,
         area: "admin",
         title: "Admin",
-        accessPolicy: PHI_VIEWER_ACCESS_DEVELOPER_TOOLS,
     }),
     ...ADMIN_OWNED_ROUTES,
 ];

package/plugins/runtime-modules/admin/trees/admin-settings-label-set.d.ts

@@ -0,0 +1,6 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../../gateway/tr";
+export declare function getPhiAdminSettingsPageLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    pageTitle: string;
+    pageDescription: string;
+}>;

package/plugins/runtime-modules/admin/trees/admin-settings-label-set.js

@@ -0,0 +1,18 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../../gateway/label-set";
+const PHI_ADMIN_SETTINGS_PAGE_LABEL_SET = definePhiLabelSet({
+    key: "preset:admin-settings-page",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        page_title: "General",
+        page_description: definePhiMessageLabel("Manage site identity and contact details for this site."),
+    },
+});
+export async function getPhiAdminSettingsPageLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_ADMIN_SETTINGS_PAGE_LABEL_SET);
+    return {
+        pageTitle: labels.page_title,
+        pageDescription: labels.page_description,
+    };
+}

package/plugins/runtime-modules/admin/trees/phi-default-admin-area-preset-tree.d.ts

@@ -0,0 +1,6 @@
+import type { PhiResolvedCmsPageTree, PhiCmsPageNode } from "../../../../types/cms";
+import type { PhiBlockRuntime } from "../../../../types";
+export declare function buildPhiDefaultAdminAreaPresetTree({ page, runtime, }: {
+    page: PhiCmsPageNode;
+    runtime: PhiBlockRuntime;
+}): Promise<PhiResolvedCmsPageTree>;