@phis/ui 0.1.0 → 0.2.1

package/plugins/runtime-modules/descriptor-compiler.js

@@ -1,16 +1,27 @@
 import { isPhiCmsAreaKey, resolvePhiCmsAreaMask, } from "../../constants/cms-areas";
 import { PhiCmsPageType, PhiCmsRegionType, PhiCmsStatus } from "../../constants/phi-cms";
-import { PhiCmsLayoutType } from "../../constants/cms-layout-types";
+import { PhiCmsLayoutType } from "../../constants/cms-layout-type-keys";
 import { createPhiPresetCmsInstanceId, createPhiPresetCmsPageId, isPhiCmsInstanceId, readPhiCmsInstanceIdDescriptor, } from "../../types/cms-instance-id";
 import { canPhiViewerAccess, PHI_VIEWER_ACCESS_ANYONE, } from "../../types/access";
 import { mergePhiCmsShellTrees, omitPhiCmsShellCompositionNodes, } from "./shell-tree-composition";
-import { buildPhiRuntimeModulePackageRoutePrefix } from "../../helpers/runtime-module-route-path";
-import { choosePhiAreaRootApplicant, isPhiAssignablePublicRoutePath, } from "../../helpers/cms-area-config";
+import { resolvePhiRuntimeModuleAreaRoutePath } from "../../helpers/runtime-module-route-path";
+import { choosePhiAreaRootApplicant, orderPhiAreaPathClaimsByCover, isPhiAssignablePublicRoutePath, } from "../../helpers/cms-area-config";
 import { resolvePhiLayoutCreationPreset } from "../../helpers/cms-layout-defaults";
 import { buildPhiBasePageLayoutNode, PHI_BASE_PAGE_LAYOUT_NODE_ID, } from "../../components/regions/presets/phi-base-page-layout";
 const PHI_CMS_REGION_TYPE_VALUES = new Set(Object.values(PhiCmsRegionType));
 const PHI_ROUTE_PARAMETER_PATTERN = /^:[A-Za-z][A-Za-z0-9_]*$/;
 const PHI_ROUTE_MOUNT_KEY_PATTERN = /^[a-z][a-z0-9-]*$/;
+const PHI_NAVIGATION_ANCHORS = new Set([
+    "start",
+    "main",
+    "settings",
+    "end",
+]);
+const PHI_NAVIGATION_ANCHOR_POSITIONS = new Set([
+    "leading",
+    "body",
+    "trailing",
+]);
 function normalizeRequiredKey(value, label) {
     const normalized = value.trim();
     if (!normalized) {
@@ -54,6 +65,10 @@ export function normalizePhiCmsRoutePath(value) {
  *
  * `/` is the exception in either case. It is an application for the Area root slot rather than a route of
  * the Module's own, so it keeps the address it asks for.
+ *
+ * The rule itself is `resolvePhiRuntimeModuleAreaRoutePath`, shared with everything that links to a
+ * Module route rather than serves one; what this function adds is the Area mount check and the
+ * insistence that a declared path arrives normalized.
  */
 function resolvePhiCmsNamespacedRouteDescriptor(descriptor, areaDefinition) {
     if (descriptor.mount) {
@@ -73,7 +88,7 @@ function resolvePhiCmsNamespacedRouteDescriptor(descriptor, areaDefinition) {
     }
     return {
         ...descriptor,
-        path: `${buildPhiRuntimeModulePackageRoutePrefix(descriptor.ownerModuleId)}${path}`,
+        path: resolvePhiRuntimeModuleAreaRoutePath(descriptor.ownerModuleId, descriptor.area, path),
     };
 }
 export function compilePhiCmsRoutePattern(descriptor) {
@@ -187,6 +202,23 @@ function assertAreaDefinitions(areaDefinitions, catalog) {
                 }
                 exportedItemKeys.add(itemKey);
             }
+            for (const [anchor, placement] of Object.entries(surface.anchors ?? {})) {
+                if (!PHI_NAVIGATION_ANCHORS.has(anchor)) {
+                    throw new Error(`${surface.navKey}: unknown navigation anchor "${anchor}".`);
+                }
+                if (!placement || !PHI_NAVIGATION_ANCHOR_POSITIONS.has(placement.position)) {
+                    throw new Error(`${surface.navKey}: navigation anchor "${anchor}" has no valid position.`);
+                }
+                if (placement.parentItemKey === null) {
+                    continue;
+                }
+                // Only a container of the Area's own: an entry that goes somewhere has no inside to put one in.
+                const parent = findNavigationItemDescriptor(surface.items, placement.parentItemKey);
+                if (!parent || parent.routePresetKey || parent.overlayPresetKey || parent.signalRoutes) {
+                    throw new Error(`${surface.navKey}: navigation anchor "${anchor}" parent ` +
+                        `"${placement.parentItemKey}" must be a navigation container of the surface.`);
+                }
+            }
         }
         const routeMountKeys = new Set();
         for (const mount of definition.routeMounts ?? []) {
@@ -220,6 +252,7 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
     const areaShellByIdentity = new Map();
     const areaOverlaysByArea = new Map();
     const routeByIdentity = new Map();
+    const routeByPageId = new Map();
     /**
      * Navigation injections a Module contributes without owning a Page, keyed by Area.
      *
@@ -309,6 +342,7 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
             const resolvedDescriptor = resolvePhiCmsNamespacedRouteDescriptor(descriptor, areaDefinition);
             const compiled = compilePhiCmsRoutePattern(resolvedDescriptor);
             routeByIdentity.set(identity, resolvedDescriptor);
+            routeByPageId.set(createPhiPresetCmsPageId({ ownerModuleId: moduleId, presetKey: descriptor.presetKey }), resolvedDescriptor);
             const areaRoutes = routesByArea.get(descriptor.area) ?? [];
             areaRoutes.push(compiled);
             routesByArea.set(descriptor.area, areaRoutes);
@@ -449,6 +483,18 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
             if (injection.before && injection.after) {
                 throw new Error(`${contributionLabel}: navigation injection cannot set before and after.`);
             }
+            if (injection.anchor !== undefined) {
+                // The type says so already; a package compiled against another copy of it may not have asked.
+                const { parentItemKey, before, after } = injection;
+                if (parentItemKey !== undefined || before !== undefined || after !== undefined) {
+                    throw new Error(`${contributionLabel}: navigation anchor "${injection.anchor}" cannot be combined with ` +
+                        "parentItemKey, before or after.");
+                }
+                if (!surface.anchors?.[injection.anchor]) {
+                    throw new Error(`${contributionLabel}: navigation surface "${injection.navKey}" declares no ` +
+                        `anchor "${injection.anchor}".`);
+                }
+            }
             // An injection without an anchor is allowed and lands at the end of its surface, ordered by
             // `${ownerModuleId}\u001f${presetKey}\u001f${itemKey}` -- deterministic, and not dependent on the
             // order Modules happened to be composed in. Requiring an anchor here would have meant a Module can
@@ -506,6 +552,7 @@ export function compilePhiCmsDescriptorCatalog({ catalog, areaDefinitions, }) {
         areaOverlaysByArea,
         moduleNavigationByArea,
         routeByIdentity,
+        routeByPageId,
         routesByArea,
         themeByKey,
         themeBlockByKey,
@@ -587,7 +634,7 @@ export function resolvePhiCmsDescriptorCatalog(catalog) {
     descriptorCatalogByRuntimeCatalog.set(catalog, compiled);
     return compiled;
 }
-export function compilePhiCmsActiveRouteTable({ catalog, area, activeModuleIds, viewer, publicRoutePaths, landingSelection, }) {
+export function compilePhiCmsActiveRouteTable({ catalog, area, activeModuleIds, publicRoutePaths, landingSelection, }) {
     const areaDefinition = catalog.areaDefinitions.get(area);
     if (!areaDefinition) {
         throw new Error(`Area "${area}" is not declared.`);
@@ -606,12 +653,14 @@ export function compilePhiCmsActiveRouteTable({ catalog, area, activeModuleIds,
      * Which application for `/` is answered, decided once before anything is compiled.
      *
      * Who wins is `choosePhiAreaRootApplicant`, shared with the Builder so the Page an author edits is
-     * the Page a visitor is served. What belongs here is only who gets to apply: active in this Area,
-     * and visible to this viewer. The applications that are not answered are not in the table at all.
+     * the Page a visitor is served. What belongs here is only who gets to apply: active in this Area. The
+     * applications that are not answered are not in the table at all.
+     *
+     * Not who is reading. An Area's front door is the same door for everybody the Area lets in, so a
+     * viewer here would make two people disagree about which Module answers `/` -- see ACCESS.md.
      */
     const rootApplicants = (catalog.routesByArea.get(area) ?? []).filter((declared) => declared.descriptor.path === "/" &&
-        activeModuleIds.has(declared.descriptor.ownerModuleId) &&
-        (!viewer || canPhiViewerAccess(viewer, declared.descriptor.accessPolicy)));
+        activeModuleIds.has(declared.descriptor.ownerModuleId));
     const chosenRoot = choosePhiAreaRootApplicant(rootApplicants, (declared) => declared.descriptor, { baseModuleId: areaDefinition.baseModuleId, landingSelection }) ?? undefined;
     const byPageId = new Map();
     const exactByPath = new Map();
@@ -626,25 +675,17 @@ export function compilePhiCmsActiveRouteTable({ catalog, area, activeModuleIds,
         : []);
     /*
      * The Public base Module's Pages are a floor, and a package Module that declares one of their paths
-     * covers it (MODULES.md, "Who owns an address"). An address answers with its first claim, so the
-     * covering is nothing more than who claims first: every other Module ahead of the base Module. The
-     * base route still enters `byPageId` below, so its identity stays active and everything pointing at
-     * it reaches the covering Page through the path. Outside Public no package can declare a base path.
+     * covers it -- `orderPhiAreaPathClaimsByCover` is that rule, shared with the Builder's Page list so
+     * the Page an author opens is the Page a visitor is served. The base route still enters `byPageId`
+     * below, so its identity stays active and everything pointing at it reaches the covering Page
+     * through the path.
      */
     const declaredRoutes = catalog.routesByArea.get(area) ?? [];
-    const orderedRoutes = area === "public"
-        ? [
-            ...declaredRoutes.filter((declared) => declared.descriptor.ownerModuleId !== areaDefinition.baseModuleId),
-            ...declaredRoutes.filter((declared) => declared.descriptor.ownerModuleId === areaDefinition.baseModuleId),
-        ]
-        : declaredRoutes;
+    const orderedRoutes = orderPhiAreaPathClaimsByCover(declaredRoutes, (declared) => declared.descriptor, { baseModuleId: area === "public" ? areaDefinition.baseModuleId : null });
     for (const declared of orderedRoutes) {
         if (!activeModuleIds.has(declared.descriptor.ownerModuleId)) {
             continue;
         }
-        if (viewer && !canPhiViewerAccess(viewer, declared.descriptor.accessPolicy)) {
-            continue;
-        }
         if (declared.descriptor.path === "/" && declared !== chosenRoot) {
             continue;
         }
@@ -715,14 +756,21 @@ function buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, navKey, o
                 nodeKey: descriptor.itemKey,
             }),
             ownerModuleId,
-            kind: target ? "link" : "container",
+            // An entry that sends is a link in the sense that matters here: it is chosen, and something
+            // happens. Only an entry that neither goes nor sends is a container.
+            kind: target || descriptor.signalRoutes?.emits?.length ? "link" : "container",
             label: descriptor.label,
             ...(descriptor.icon ? { icon: descriptor.icon } : {}),
             ...(descriptor.accessPolicy ? { accessPolicy: descriptor.accessPolicy } : {}),
+            ...(descriptor.signalRoutes?.emits?.length
+                ? { emits: descriptor.signalRoutes.emits }
+                : {}),
             target,
             children: [],
         },
         definitionItemKey: descriptor.itemKey,
+        // Only an Area's own entry carries it; a contribution is placed by its anchor or `before`/`after`.
+        standsLast: "standing" in descriptor && descriptor.standing === "last",
         // An item that named a route and got nothing back. A container never is one: it named nothing.
         isUnrouted: Boolean(descriptor.routePresetKey) && !target,
         intrinsicChildren,
@@ -730,15 +778,31 @@ function buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, navKey, o
     };
 }
 function orderNavigationSiblings(intrinsic, injected, parentItemKey) {
-    const ordered = [...intrinsic];
-    const pending = [...injected].sort((left, right) => left.injection.sortKey.localeCompare(right.injection.sortKey));
+    /*
+     * An Area's entries first, the contributed ones after -- except the entries that said they stand
+     * last, which are held back and put on the end once everything else has found its place.
+     *
+     * They are held out of the list the anchoring pass inserts into, not out of the anchoring: an entry
+     * that stands last is exported like any other and Modules do anchor against it. What changes is
+     * only where that lands, which the pass below says.
+     */
+    const sorted = [...injected].sort((left, right) => left.injection.sortKey.localeCompare(right.injection.sortKey));
+    /*
+     * Anchored entries at the two ends are placed before anything is inserted, so an entry placed by
+     * item key may still name one of them when it is the Module's own. `body` is the place an entry
+     * naming no anchor has always gone, so it simply joins those below.
+     */
+    const inPosition = (position) => sorted.filter((node) => node.injection.position === position);
+    const trailing = [...intrinsic.filter((node) => node.standsLast), ...inPosition("trailing")];
+    const ordered = [...inPosition("leading"), ...intrinsic.filter((node) => !node.standsLast)];
+    const pending = sorted.filter(({ injection }) => injection.position !== "leading" && injection.position !== "trailing");
     while (pending.length > 0) {
         let inserted = false;
         const anchors = new Map();
         const unanchored = [];
         for (const node of pending) {
             const descriptor = node.injection.descriptor;
-            const anchor = descriptor.before ?? descriptor.after ?? null;
+            const anchor = node.injection.position ? null : descriptor.before ?? descriptor.after ?? null;
             if (!anchor) {
                 unanchored.push(node);
                 continue;
@@ -750,6 +814,24 @@ function orderNavigationSiblings(intrinsic, injected, parentItemKey) {
         for (const [anchor, group] of [...anchors].sort(([left], [right]) => left.localeCompare(right))) {
             let anchorIndex = ordered.findIndex((node) => node.definitionItemKey === anchor);
             if (anchorIndex < 0) {
+                /*
+                 * An anchor on an entry that stands last still means what it says.
+                 *
+                 * Such an entry is exported like any other -- a Module written before sidebar anchors placed
+                 * its Admin pages before the Settings container -- so refusing it here would break a published
+                 * anchor over an ordering detail. "Before" is the end of everything standing ahead of it,
+                 * "after" is behind it and ahead of whatever the Area's `end` anchor holds.
+                 */
+                const trailingIndex = trailing.findIndex((node) => node.definitionItemKey === anchor);
+                if (trailingIndex < 0) {
+                    continue;
+                }
+                ordered.push(...group.before);
+                trailing.splice(trailingIndex + 1, 0, ...group.after);
+                for (const node of [...group.before, ...group.after]) {
+                    pending.splice(pending.indexOf(node), 1);
+                }
+                inserted = true;
                 continue;
             }
             ordered.splice(anchorIndex, 0, ...group.before);
@@ -775,7 +857,7 @@ function orderNavigationSiblings(intrinsic, injected, parentItemKey) {
             throw new Error(`Navigation injections below "${parentItemKey ?? "root"}" have unresolved or cyclic anchors: ${unresolved.join(", ")}.`);
         }
     }
-    return ordered;
+    return [...ordered, ...trailing];
 }
 export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeModuleIds, viewer, }) {
     const definition = catalog.areaDefinitions.get(area);
@@ -785,11 +867,22 @@ export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeMod
     if (!activeModuleIds.has(definition.baseModuleId)) {
         throw new Error(`Area "${area}" base module "${definition.baseModuleId}" is not active.`);
     }
+    /*
+     * Which routes exist, and nothing about who is reading.
+     *
+     * A route is in or out by Module selection alone. An entry may still hide from one reader -- that is
+     * the next block, and it is the entry's own statement -- but the set of addresses this Area answers is
+     * one set (ACCESS.md).
+     */
     const activeRoutes = (catalog.routesByArea.get(area) ?? [])
         .map(({ descriptor }) => descriptor)
-        .filter(({ ownerModuleId }) => activeModuleIds.has(ownerModuleId))
-        .filter((route) => !viewer || canPhiViewerAccess(viewer, route.accessPolicy));
+        .filter(({ ownerModuleId }) => activeModuleIds.has(ownerModuleId));
     const activeRouteIdentityKeys = new Set(activeRoutes.map((route) => buildPhiCmsPresetIdentityKey(route.ownerModuleId, route.presetKey)));
+    /*
+     * Whether this reader is shown the entry, which is a different question from whether the address
+     * answers. An entry says this for itself; it is never read off the route it points at, because the
+     * route is the same route for everybody and a hidden entry must not imply a missing address.
+     */
     const isNavigationNodeVisible = (node) => {
         if (node.isUnrouted) {
             return false;
@@ -797,10 +890,7 @@ export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeMod
         if (!viewer) {
             return true;
         }
-        const routePolicy = node.item.target?.kind === "module"
-            ? catalog.routeByIdentity.get(buildPhiCmsPresetIdentityKey(node.item.target.ownerModuleId, node.item.target.presetKey))?.accessPolicy
-            : undefined;
-        return canPhiViewerAccess(viewer, node.item.accessPolicy ?? routePolicy);
+        return canPhiViewerAccess(viewer, node.item.accessPolicy);
     };
     return (definition.navigationSurfaces ?? []).map((surface) => {
         const roots = surface.items
@@ -840,15 +930,18 @@ export function resolvePhiCmsActiveNavigationSurfaces({ catalog, area, activeMod
                 if (descriptor.navKey !== surface.navKey) {
                     continue;
                 }
-                const node = buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, surface.navKey, contributorId, descriptor.item, { descriptor, route, sortKey });
+                // Compiled against the surface already, so a named anchor is one the surface declares.
+                const placement = descriptor.anchor ? surface.anchors[descriptor.anchor] : null;
+                const parentItemKey = placement ? placement.parentItemKey : descriptor.parentItemKey;
+                const node = buildResolvedNavigationNode(catalog, activeRouteIdentityKeys, surface.navKey, contributorId, descriptor.item, { descriptor, route, sortKey, position: placement?.position ?? null });
                 registerNode(node);
-                if (descriptor.parentItemKey === null) {
+                if (parentItemKey === null) {
                     injectedRoots.push(node);
                 }
                 else {
-                    const siblings = injectedByParent.get(descriptor.parentItemKey) ?? [];
+                    const siblings = injectedByParent.get(parentItemKey) ?? [];
                     siblings.push(node);
-                    injectedByParent.set(descriptor.parentItemKey, siblings);
+                    injectedByParent.set(parentItemKey, siblings);
                 }
             }
         }
@@ -1087,6 +1180,20 @@ export function resolvePhiCmsAreaShellPresetBinding(catalog, area) {
 export function resolvePhiCmsRoutePresetByIdentity(catalog, ownerModuleId, presetKey) {
     return catalog.routeByIdentity.get(buildPhiCmsPresetIdentityKey(ownerModuleId, presetKey)) ?? null;
 }
+/**
+ * The route a Module Page reference names, read off the whole catalogue.
+ *
+ * A reference carries the derived Page id and not the pair it was derived from, so this is the only way
+ * in from a stored link: the hash cannot be undone, and the catalogue is the other side of it.
+ *
+ * The Area's active route table answers the same question for what that Area actually serves, and where
+ * a caller has one it is the better question -- it has already dropped the Modules that are switched off
+ * and the root applicants that lost. This one is for a caller holding only the catalogue, and it leaves
+ * those checks to them.
+ */
+export function resolvePhiCmsRouteDescriptorByPageId(catalog, pageId) {
+    return catalog.routeByPageId.get(pageId) ?? null;
+}
 export function resolvePhiCmsThemePresetBinding(catalog, themeKey, activeModuleIds) {
     const binding = catalog.themeByKey.get(themeKey.trim()) ?? null;
     return binding && activeModuleIds.has(binding.descriptor.ownerModuleId) ? binding : null;

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

@@ -1,5 +1,3 @@
 export declare const PHI_EDITOR_CONTROLLER_PLUGIN_KEY = "@phis/ui/modules/editor/controller";
 export declare const PHI_EDITOR_CONTROLLER_KEY = "default";
 export declare const PHI_EDITOR_CONTROLLER_TYPE: "@phis/ui/modules/editor/controller/default";
-export declare const PHI_EDITOR_CONTROLLER_INSTANCE_KEY = "default";
-export declare function createPhiEditorControllerAddress(): `controller:${string}/${string}:${string}`;

package/plugins/runtime-modules/editor/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_EDITOR_CONTROLLER_PLUGIN_KEY = `${PHI_SHARED_PACKAGE_NAME}/modules/editor/controller`;
 export const PHI_EDITOR_CONTROLLER_KEY = "default";
 export const PHI_EDITOR_CONTROLLER_TYPE = `${PHI_EDITOR_CONTROLLER_PLUGIN_KEY}/${PHI_EDITOR_CONTROLLER_KEY}`;
-export const PHI_EDITOR_CONTROLLER_INSTANCE_KEY = "default";
-export function createPhiEditorControllerAddress() {
-    return createPhiControllerSignalAddress(PHI_EDITOR_CONTROLLER_PLUGIN_KEY, PHI_EDITOR_CONTROLLER_KEY, PHI_EDITOR_CONTROLLER_INSTANCE_KEY);
-}

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

@@ -1,28 +1 @@
-export declare const PHI_EDITOR_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/editor/controller/definition").PhiEditorControllerConfig;
-    };
-    description: string;
-    category: "foundation";
-    iconFamily: string;
-    controller: import("../contracts").PhiRuntimeModuleControllerDescriptor;
-    moduleId: "@phis/ui/modules/editor";
-    serverBinding: import("../../../types").PhiRuntimeModuleServerBinding;
-    controllerType: "@phis/ui/modules/editor/controller/default";
-    controllerMountPolicy: "area";
-    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_EDITOR_RUNTIME_MODULE: import("../contracts").PhiRuntimeModule;

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

@@ -1,6 +1,4 @@
 import { PHI_EDITOR_RUNTIME_CONTROLLER_DEFINITION } from "../../../plugins/runtime-modules/editor/controller/definition";
 import { PHI_EDITOR_RUNTIME_MODULE_DEFINITION } from "./definition";
-export const PHI_EDITOR_RUNTIME_MODULE = {
-    ...PHI_EDITOR_RUNTIME_MODULE_DEFINITION,
-    controllerDefinition: PHI_EDITOR_RUNTIME_CONTROLLER_DEFINITION,
-};
+import { createPhiAreaBaseRuntimeModule } from "../area-base-module";
+export const PHI_EDITOR_RUNTIME_MODULE = createPhiAreaBaseRuntimeModule(PHI_EDITOR_RUNTIME_MODULE_DEFINITION, PHI_EDITOR_RUNTIME_CONTROLLER_DEFINITION);

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

@@ -1,4 +1,3 @@
-import { PHI_BASE_PAGE_LAYOUT_VERSION } from "../../../components/regions/presets/phi-base-page-layout";
 import { buildPhiAreaRootRoutePresetDescriptor } from "../area-root-route";
 import { PHI_EDITOR_RUNTIME_MODULE_ID } from "./ids";
 export const PHI_EDITOR_RUNTIME_MODULE_AREA_SHELLS = [{
@@ -6,20 +5,11 @@ export const PHI_EDITOR_RUNTIME_MODULE_AREA_SHELLS = [{
         presetKey: "editor-area-preset",
         shellPresetVersion: 1,
         area: "editor",
-        loadTree: ({ page, runtime }) => import("../../../components/regions/presets/phi-default-editor-area-preset-tree")
+        loadTree: ({ page, runtime }) => import("./trees/phi-default-editor-area-preset-tree")
             .then((module) => module.buildPhiDefaultEditorAreaPresetTree({ page, runtime })),
     }];
 export const PHI_EDITOR_RUNTIME_MODULE_ROUTES = [buildPhiAreaRootRoutePresetDescriptor({
         ownerModuleId: PHI_EDITOR_RUNTIME_MODULE_ID,
         area: "editor",
         title: "Editor",
-    }), {
-        ownerModuleId: PHI_EDITOR_RUNTIME_MODULE_ID,
-        presetKey: "editor-translations-page",
-        presetVersion: 1 + PHI_BASE_PAGE_LAYOUT_VERSION,
-        area: "editor",
-        title: "Translations",
-        path: "/translations",
-        loadTree: ({ page, runtime }) => import("../../../components/regions/presets/phi-default-editor-translations-page-tree")
-            .then((module) => module.buildPhiDefaultEditorTranslationsPageTree({ page, runtime })),
-    }];
+    })];

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

@@ -0,0 +1,8 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../../gateway/tr";
+export declare function getPhiEditorAreaLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    dashboard: string;
+    text: string;
+    translations: string;
+    profile: string;
+}>;

package/plugins/runtime-modules/editor/trees/editor-label-set.js

@@ -0,0 +1,22 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../../gateway/tr";
+import { definePhiLabelSet, getPhiLabelSet } from "../../../../gateway/label-set";
+const PHI_EDITOR_AREA_LABEL_SET = definePhiLabelSet({
+    key: "preset:editor-area",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        dashboard: "Dashboard",
+        text: "Edit text",
+        translations: "Translations",
+        profile: "Profile",
+    },
+});
+export async function getPhiEditorAreaLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_EDITOR_AREA_LABEL_SET);
+    return {
+        dashboard: labels.dashboard,
+        text: labels.text,
+        translations: labels.translations,
+        profile: labels.profile,
+    };
+}

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

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