@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/compose-layout-nodes.js

@@ -0,0 +1,261 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { NODE_ROOT_ID } from "../canvas-manager/canvas-manager.js";
+import { COMPONENT_NODE_ID_PREFIX } from "./reusable-component-keys.js";
+import { mergeNodeSx } from "./merge-node-sx.js";
+/** Persisted component id of the layout content outlet (plugins-mui). */ export const LAYOUT_SLOT_COMPONENT_ID = 'layoutSlot';
+/**
+ * Prefix applied to layout node ids during composition so they can never
+ * collide with screen node ids (layout ids repeat across every bound
+ * screen).
+ */ export const LAYOUT_NODE_ID_PREFIX = 'layout__';
+/**
+ * How many layouts deep a chain may nest (AGL-703).
+ *
+ * A layout can render inside another layout, so the chain is walked rather
+ * than read once. This bounds it: a cycle is already refused at both write
+ * time and resolution time, and this is the belt to that pair of braces —
+ * a hand-edited document must not be able to hang a render.
+ */ export const MAX_LAYOUT_CHAIN_DEPTH = 5;
+/**
+ * Namespace for one level of the layout chain (AGL-703).
+ *
+ * Depth 1 — the layout a screen names directly — keeps the original
+ * `layout__` exactly. Every interaction authored before nesting existed
+ * stores raw canvas ids that {@link normalizeLeafId} matches against this
+ * prefix, so changing it would silently break them. Outer levels take
+ * `layout2__`, `layout3__`, … which is what keeps a grandparent layout's
+ * node ids from colliding with its child's: without a per-level namespace,
+ * two layouts in one chain sharing a node id would collapse into one node.
+ */ export function layoutNodeIdPrefix(depth = 1) {
+    return depth <= 1 ? LAYOUT_NODE_ID_PREFIX : `layout${depth}__`;
+}
+/** Every namespace a composed tree can carry, outermost depth first. */ export const LAYOUT_NODE_ID_PREFIXES = Array.from({
+    length: MAX_LAYOUT_CHAIN_DEPTH
+}, (_unused, index)=>layoutNodeIdPrefix(index + 1));
+/**
+ * Whether a composed node id came from the LAYOUT chain rather than from the
+ * screen (AGL-1871).
+ *
+ * Composition namespaces ids by origin and nothing else does: a layout node
+ * is `layout__{id}` (`layout2__` … `layout5__` further up the chain, see
+ * {@link layoutNodeIdPrefix}) while a screen node keeps its raw canvas id. A
+ * reusable component grafted onto either one wears its host's id inside its
+ * own namespace — the marketing nav really ships as
+ * `cmp__layout__52Ef-3t6yd___R91yATrXH` — so the graft prefixes are peeled
+ * before the origin is read, and a graft nested in a graft peels the same way.
+ *
+ * A raw canvas id cannot collide with this: nanoid emits a single token with
+ * no `__` boundary in it, so `layout__` can only be a prefix that composition
+ * put there.
+ */ export function isLayoutComposedNodeId(id) {
+    let value = String(id != null ? id : '');
+    while(value.startsWith(COMPONENT_NODE_ID_PREFIX)){
+        value = value.slice(COMPONENT_NODE_ID_PREFIX.length);
+    }
+    return LAYOUT_NODE_ID_PREFIXES.some((prefix)=>value.startsWith(prefix));
+}
+/**
+ * Whether a composed tree contains anything the SCREEN put there (AGL-1871).
+ *
+ * `composeLayoutAndScreenNodes` always answers with a populated map when the
+ * host has a layout, because the layout chrome is in it whether or not the
+ * screen contributed a single node. So "compose returned nodes" is not the
+ * same question as "this screen has a page on it", and code that treats the
+ * two as one renders a header and a footer around nothing.
+ *
+ * That is not hypothetical. Measured on `aglyn.com` 2026-08-23, the published
+ * *"Not found (404)"* screen composed to **297 nodes, every one of them layout
+ * chrome**, with the `layoutSlot` holding an empty child list — the screen was
+ * routed, published and completely empty. The 404 boundary read the 297 as
+ * "the site has a designed 404", declined its own fallback, and every unmatched
+ * URL on the site served branding wrapped around a blank page.
+ *
+ * The root node is not evidence — composition synthesizes one for an empty
+ * screen — so it is excluded.
+ */ export function hasScreenAuthoredNodes(nodes) {
+    if (!nodes) return false;
+    for (const id of Object.keys(nodes)){
+        if (id === NODE_ROOT_ID) continue;
+        if (!isLayoutComposedNodeId(id)) return true;
+    }
+    return false;
+}
+function prefixLayoutId(id, prefix) {
+    return id === NODE_ROOT_ID ? id : `${prefix}${id}`;
+}
+function prefixChildIds(nodes, prefix) {
+    if (!Array.isArray(nodes)) return nodes;
+    return nodes.map((id)=>typeof id === 'string' ? prefixLayoutId(id, prefix) : id);
+}
+/**
+ * Grafts a screen's nodes into its layout's LayoutSlot, producing one
+ * normalized node map rooted at the layout root.
+ *
+ * - Layout node ids are namespaced with {@link LAYOUT_NODE_ID_PREFIX} (the
+ *   root id excepted) to avoid collisions with screen ids.
+ * - The screen root's children are appended to the slot's own children and
+ *   repointed at the slot. Slot children shouldn't normally exist, but
+ *   designers do land chrome inside the slot — rendering it above the
+ *   screen content preserves their intent instead of silently dropping it.
+ * - Inputs are never mutated. Without layout nodes — or when the layout has
+ *   no slot — the screen nodes are returned unchanged so a stale or broken
+ *   layout can't take a published screen down.
+ */ export function composeLayoutAndScreenNodes(layoutNodes, screenNodes, /** Position in the layout chain; 1 = the layout the screen names. */ depth = 1) {
+    var _composed_slotId, _composed_slotId1;
+    if (!layoutNodes || !layoutNodes[NODE_ROOT_ID]) return screenNodes;
+    const slotEntry = Object.entries(layoutNodes).find(([, node])=>(node == null ? void 0 : node.componentId) === LAYOUT_SLOT_COMPONENT_ID);
+    if (!slotEntry) return screenNodes;
+    const prefix = layoutNodeIdPrefix(depth);
+    const composed = {};
+    for (const [id, node] of Object.entries(layoutNodes)){
+        var _node_$id;
+        const nextId = prefixLayoutId(id, prefix);
+        composed[nextId] = _extends({}, node, {
+            // Early seeds stored roots without $id or componentId, letting the
+            // canvas assign fallbacks — trust the map key so root identity stays
+            // canonical, and pin the root to a plain container so production
+            // renderers (which have no canvas defaults) can resolve it.
+            $id: id === NODE_ROOT_ID ? NODE_ROOT_ID : prefixLayoutId((_node_$id = node.$id) != null ? _node_$id : id, prefix)
+        }, id === NODE_ROOT_ID && !node.componentId && {
+            componentId: 'div'
+        }, node.parentId != null && {
+            parentId: prefixLayoutId(node.parentId, prefix)
+        }, node.nodes != null && {
+            nodes: prefixChildIds(node.nodes, prefix)
+        });
+    }
+    const slotId = prefixLayoutId(slotEntry[0], prefix);
+    const screenRoot = screenNodes[NODE_ROOT_ID];
+    const screenRootChildIds = Array.isArray(screenRoot == null ? void 0 : screenRoot.nodes) ? [
+        ...screenRoot.nodes
+    ] : [];
+    const slotChildIds = Array.isArray((_composed_slotId = composed[slotId]) == null ? void 0 : _composed_slotId.nodes) ? composed[slotId].nodes : [];
+    // The screen root is DROPPED — its children reparent to the slot — so
+    // whatever was styled on it has to land somewhere or it is simply lost.
+    // It was: a background painted on the `Document` layer showed in the
+    // besigner (which renders the screen alone, root included) and never on the
+    // published page, where the layout root is the only root and the screen's
+    // was gone. The slot is where those children now live, so it is where the
+    // screen root's own styling belongs — the same node, one composition later.
+    //
+    // Slot first, screen root after: a screen may override the layout's own
+    // styling of the region it fills, which is the direction of intent
+    // everywhere else composition merges (a component instance over its
+    // definition, AGL-1306).
+    const mergedSlotSx = mergeNodeSx((_composed_slotId1 = composed[slotId]) == null ? void 0 : _composed_slotId1.sx, screenRoot == null ? void 0 : screenRoot.sx);
+    // `className` is on the canvas node, not on the structural type this
+    // function is generic over, so it is read through a narrow cast rather than
+    // by widening the signature.
+    const classNameOf = (node)=>node == null ? void 0 : node.className;
+    const mergedSlotClassName = [
+        classNameOf(composed[slotId]),
+        classNameOf(screenRoot)
+    ].filter(Boolean).join(' ') || undefined;
+    composed[slotId] = _extends({}, composed[slotId], {
+        nodes: [
+            ...slotChildIds,
+            ...screenRootChildIds
+        ]
+    }, mergedSlotSx == null ? {} : {
+        sx: mergedSlotSx
+    }, mergedSlotClassName ? {
+        className: mergedSlotClassName
+    } : {});
+    for (const [id, node] of Object.entries(screenNodes)){
+        if (id === NODE_ROOT_ID) continue;
+        const isTopLevel = (node == null ? void 0 : node.parentId) === NODE_ROOT_ID;
+        composed[id] = isTopLevel ? _extends({}, node, {
+            parentId: slotId
+        }) : node;
+    }
+    // Top-level screen nodes may rely on child arrays alone (no parentId).
+    for (const childId of screenRootChildIds){
+        const node = composed[childId];
+        if (node && node.parentId !== slotId) {
+            composed[childId] = _extends({}, node, {
+                parentId: slotId
+            });
+        }
+    }
+    return composed;
+}
+/**
+ * Grafts a screen through a CHAIN of layouts, innermost first (AGL-703).
+ *
+ * `layoutNodesChain[0]` is the layout the screen names, `[1]` is that
+ * layout's own layout, and so on outward. Each step drops the previous
+ * result into the next layout's slot, so the outermost layout ends up as
+ * the root — the same relationship a screen has always had with its layout,
+ * applied one more time.
+ *
+ * A layout with no slot is skipped rather than fatal, and skipping it does
+ * not strand the layouts outside it: the accumulated tree simply passes
+ * through. That matches the single-layout behaviour, where a broken layout
+ * degrades to the bare screen instead of taking a published page down.
+ *
+ * Cycles are refused before this point (see `resolveLayoutChainIds`), and
+ * the chain is capped at {@link MAX_LAYOUT_CHAIN_DEPTH} regardless.
+ */ export function composeLayoutChainAndScreenNodes(layoutNodesChain, screenNodes) {
+    let composed = screenNodes;
+    const chain = layoutNodesChain.slice(0, MAX_LAYOUT_CHAIN_DEPTH);
+    for (const [index, layoutNodes] of chain.entries()){
+        composed = composeLayoutAndScreenNodes(layoutNodes, composed, index + 1);
+    }
+    return composed;
+}
+/**
+ * Walks a layout's ancestry into a flat chain, innermost first (AGL-703).
+ *
+ * `parentOf` returns the layout a given layout renders inside, or undefined
+ * at the top. The walk stops on:
+ *
+ * - **self-reference** — a layout naming itself, which is the case worth
+ *   naming out loud because it is the easy mistake to make;
+ * - **any repeat** — A → B → A would otherwise recurse forever, and a
+ *   guard that only catches self-reference would miss it;
+ * - **depth** — {@link MAX_LAYOUT_CHAIN_DEPTH}.
+ *
+ * Stopping (rather than throwing) is deliberate: a cycle in stored data
+ * should render the layouts up to the repeat, not blank the site.
+ */ export function resolveLayoutChainIds(layoutId, parentOf) {
+    const chain = [];
+    const seen = new Set();
+    let current = layoutId ? String(layoutId) : undefined;
+    while(current && !seen.has(current) && chain.length < MAX_LAYOUT_CHAIN_DEPTH){
+        chain.push(current);
+        seen.add(current);
+        const parent = parentOf(current);
+        current = parent ? String(parent) : undefined;
+    }
+    return chain;
+}
+/**
+ * Whether `candidateParentId` may be set as `layoutId`'s parent layout.
+ *
+ * Refuses self-reference and any candidate that already has this layout
+ * somewhere above it — picking one would close a loop. This is the
+ * write-time half; `resolveLayoutChainIds` stays defensive anyway, because
+ * a document can be edited by something that never called this.
+ */ export function canNestLayout(layoutId, candidateParentId, parentOf) {
+    if (!layoutId || !candidateParentId) return false;
+    if (layoutId === candidateParentId) return false;
+    return !resolveLayoutChainIds(candidateParentId, parentOf).includes(layoutId);
+}
+export default composeLayoutAndScreenNodes;
+
+//# sourceMappingURL=compose-layout-nodes.js.map

package/src/lib/app-utils/compose-layout-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/compose-layout-nodes.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { AglynNodeSchema, NodeId } from '../foundation'\nimport { NODE_ROOT_ID } from '../canvas-manager/canvas-manager'\nimport { COMPONENT_NODE_ID_PREFIX } from './reusable-component-keys'\nimport { mergeNodeSx } from './merge-node-sx'\n\n/** Persisted component id of the layout content outlet (plugins-mui). */\nexport const LAYOUT_SLOT_COMPONENT_ID = 'layoutSlot'\n\n/**\n * Prefix applied to layout node ids during composition so they can never\n * collide with screen node ids (layout ids repeat across every bound\n * screen).\n */\nexport const LAYOUT_NODE_ID_PREFIX = 'layout__'\n\n/**\n * How many layouts deep a chain may nest (AGL-703).\n *\n * A layout can render inside another layout, so the chain is walked rather\n * than read once. This bounds it: a cycle is already refused at both write\n * time and resolution time, and this is the belt to that pair of braces —\n * a hand-edited document must not be able to hang a render.\n */\nexport const MAX_LAYOUT_CHAIN_DEPTH = 5\n\n/**\n * Namespace for one level of the layout chain (AGL-703).\n *\n * Depth 1 — the layout a screen names directly — keeps the original\n * `layout__` exactly. Every interaction authored before nesting existed\n * stores raw canvas ids that {@link normalizeLeafId} matches against this\n * prefix, so changing it would silently break them. Outer levels take\n * `layout2__`, `layout3__`, … which is what keeps a grandparent layout's\n * node ids from colliding with its child's: without a per-level namespace,\n * two layouts in one chain sharing a node id would collapse into one node.\n */\nexport function layoutNodeIdPrefix(depth = 1): string {\n  return depth <= 1 ? LAYOUT_NODE_ID_PREFIX : `layout${depth}__`\n}\n\n/** Every namespace a composed tree can carry, outermost depth first. */\nexport const LAYOUT_NODE_ID_PREFIXES = Array.from(\n  { length: MAX_LAYOUT_CHAIN_DEPTH },\n  (_unused, index) => layoutNodeIdPrefix(index + 1),\n)\n\n/**\n * Whether a composed node id came from the LAYOUT chain rather than from the\n * screen (AGL-1871).\n *\n * Composition namespaces ids by origin and nothing else does: a layout node\n * is `layout__{id}` (`layout2__` … `layout5__` further up the chain, see\n * {@link layoutNodeIdPrefix}) while a screen node keeps its raw canvas id. A\n * reusable component grafted onto either one wears its host's id inside its\n * own namespace — the marketing nav really ships as\n * `cmp__layout__52Ef-3t6yd___R91yATrXH` — so the graft prefixes are peeled\n * before the origin is read, and a graft nested in a graft peels the same way.\n *\n * A raw canvas id cannot collide with this: nanoid emits a single token with\n * no `__` boundary in it, so `layout__` can only be a prefix that composition\n * put there.\n */\nexport function isLayoutComposedNodeId(id: string | undefined | null): boolean {\n  let value = String(id ?? '')\n  while (value.startsWith(COMPONENT_NODE_ID_PREFIX)) {\n    value = value.slice(COMPONENT_NODE_ID_PREFIX.length)\n  }\n  return LAYOUT_NODE_ID_PREFIXES.some((prefix) => value.startsWith(prefix))\n}\n\n/**\n * Whether a composed tree contains anything the SCREEN put there (AGL-1871).\n *\n * `composeLayoutAndScreenNodes` always answers with a populated map when the\n * host has a layout, because the layout chrome is in it whether or not the\n * screen contributed a single node. So \"compose returned nodes\" is not the\n * same question as \"this screen has a page on it\", and code that treats the\n * two as one renders a header and a footer around nothing.\n *\n * That is not hypothetical. Measured on `aglyn.com` 2026-08-23, the published\n * *\"Not found (404)\"* screen composed to **297 nodes, every one of them layout\n * chrome**, with the `layoutSlot` holding an empty child list — the screen was\n * routed, published and completely empty. The 404 boundary read the 297 as\n * \"the site has a designed 404\", declined its own fallback, and every unmatched\n * URL on the site served branding wrapped around a blank page.\n *\n * The root node is not evidence — composition synthesizes one for an empty\n * screen — so it is excluded.\n */\nexport function hasScreenAuthoredNodes(\n  nodes: Record<string, unknown> | null | undefined,\n): boolean {\n  if (!nodes) return false\n  for (const id of Object.keys(nodes)) {\n    if (id === NODE_ROOT_ID) continue\n    if (!isLayoutComposedNodeId(id)) return true\n  }\n  return false\n}\n\ntype NormalizedNodes<N extends AglynNodeSchema> = Record<NodeId, N>\n\nfunction prefixLayoutId(id: NodeId, prefix: string): NodeId {\n  return id === NODE_ROOT_ID ? id : `${prefix}${id}`\n}\n\nfunction prefixChildIds(nodes: AglynNodeSchema['nodes'], prefix: string) {\n  if (!Array.isArray(nodes)) return nodes\n  return (nodes as NodeId[]).map((id) =>\n    typeof id === 'string' ? prefixLayoutId(id, prefix) : id,\n  )\n}\n\n/**\n * Grafts a screen's nodes into its layout's LayoutSlot, producing one\n * normalized node map rooted at the layout root.\n *\n * - Layout node ids are namespaced with {@link LAYOUT_NODE_ID_PREFIX} (the\n *   root id excepted) to avoid collisions with screen ids.\n * - The screen root's children are appended to the slot's own children and\n *   repointed at the slot. Slot children shouldn't normally exist, but\n *   designers do land chrome inside the slot — rendering it above the\n *   screen content preserves their intent instead of silently dropping it.\n * - Inputs are never mutated. Without layout nodes — or when the layout has\n *   no slot — the screen nodes are returned unchanged so a stale or broken\n *   layout can't take a published screen down.\n */\nexport function composeLayoutAndScreenNodes<\n  N extends AglynNodeSchema = AglynNodeSchema,\n>(\n  layoutNodes: NormalizedNodes<N> | undefined,\n  screenNodes: NormalizedNodes<N>,\n  /** Position in the layout chain; 1 = the layout the screen names. */\n  depth = 1,\n): NormalizedNodes<N> {\n  if (!layoutNodes || !layoutNodes[NODE_ROOT_ID]) return screenNodes\n\n  const slotEntry = Object.entries(layoutNodes).find(\n    ([, node]) => node?.componentId === LAYOUT_SLOT_COMPONENT_ID,\n  )\n  if (!slotEntry) return screenNodes\n\n  const prefix = layoutNodeIdPrefix(depth)\n  const composed: NormalizedNodes<N> = {}\n\n  for (const [id, node] of Object.entries(layoutNodes)) {\n    const nextId = prefixLayoutId(id, prefix)\n    composed[nextId] = {\n      ...node,\n      // Early seeds stored roots without $id or componentId, letting the\n      // canvas assign fallbacks — trust the map key so root identity stays\n      // canonical, and pin the root to a plain container so production\n      // renderers (which have no canvas defaults) can resolve it.\n      $id:\n        id === NODE_ROOT_ID\n          ? NODE_ROOT_ID\n          : prefixLayoutId(node.$id ?? id, prefix),\n      ...(id === NODE_ROOT_ID &&\n        !node.componentId && { componentId: 'div' as N['componentId'] }),\n      ...(node.parentId != null && {\n        parentId: prefixLayoutId(node.parentId, prefix),\n      }),\n      ...(node.nodes != null && { nodes: prefixChildIds(node.nodes, prefix) }),\n    }\n  }\n\n  const slotId = prefixLayoutId(slotEntry[0], prefix)\n  const screenRoot = screenNodes[NODE_ROOT_ID]\n  const screenRootChildIds = Array.isArray(screenRoot?.nodes)\n    ? ([...screenRoot.nodes] as NodeId[])\n    : []\n  const slotChildIds = Array.isArray(composed[slotId]?.nodes)\n    ? (composed[slotId].nodes as NodeId[])\n    : []\n\n  // The screen root is DROPPED — its children reparent to the slot — so\n  // whatever was styled on it has to land somewhere or it is simply lost.\n  // It was: a background painted on the `Document` layer showed in the\n  // besigner (which renders the screen alone, root included) and never on the\n  // published page, where the layout root is the only root and the screen's\n  // was gone. The slot is where those children now live, so it is where the\n  // screen root's own styling belongs — the same node, one composition later.\n  //\n  // Slot first, screen root after: a screen may override the layout's own\n  // styling of the region it fills, which is the direction of intent\n  // everywhere else composition merges (a component instance over its\n  // definition, AGL-1306).\n  const mergedSlotSx = mergeNodeSx(composed[slotId]?.sx, screenRoot?.sx)\n  // `className` is on the canvas node, not on the structural type this\n  // function is generic over, so it is read through a narrow cast rather than\n  // by widening the signature.\n  const classNameOf = (node: N | undefined): string | undefined =>\n    (node as { className?: string } | undefined)?.className\n  const mergedSlotClassName =\n    [classNameOf(composed[slotId]), classNameOf(screenRoot)]\n      .filter(Boolean)\n      .join(' ') || undefined\n  composed[slotId] = {\n    ...composed[slotId],\n    nodes: [...slotChildIds, ...screenRootChildIds],\n    ...(mergedSlotSx == null ? {} : { sx: mergedSlotSx as N['sx'] }),\n    ...(mergedSlotClassName ? { className: mergedSlotClassName } : {}),\n  }\n\n  for (const [id, node] of Object.entries(screenNodes)) {\n    if (id === NODE_ROOT_ID) continue\n    const isTopLevel = node?.parentId === NODE_ROOT_ID\n    composed[id] = isTopLevel ? { ...node, parentId: slotId } : node\n  }\n  // Top-level screen nodes may rely on child arrays alone (no parentId).\n  for (const childId of screenRootChildIds) {\n    const node = composed[childId]\n    if (node && node.parentId !== slotId) {\n      composed[childId] = { ...node, parentId: slotId }\n    }\n  }\n\n  return composed\n}\n\n/**\n * Grafts a screen through a CHAIN of layouts, innermost first (AGL-703).\n *\n * `layoutNodesChain[0]` is the layout the screen names, `[1]` is that\n * layout's own layout, and so on outward. Each step drops the previous\n * result into the next layout's slot, so the outermost layout ends up as\n * the root — the same relationship a screen has always had with its layout,\n * applied one more time.\n *\n * A layout with no slot is skipped rather than fatal, and skipping it does\n * not strand the layouts outside it: the accumulated tree simply passes\n * through. That matches the single-layout behaviour, where a broken layout\n * degrades to the bare screen instead of taking a published page down.\n *\n * Cycles are refused before this point (see `resolveLayoutChainIds`), and\n * the chain is capped at {@link MAX_LAYOUT_CHAIN_DEPTH} regardless.\n */\nexport function composeLayoutChainAndScreenNodes<\n  N extends AglynNodeSchema = AglynNodeSchema,\n>(\n  layoutNodesChain: Array<NormalizedNodes<N> | undefined>,\n  screenNodes: NormalizedNodes<N>,\n): NormalizedNodes<N> {\n  let composed = screenNodes\n  const chain = layoutNodesChain.slice(0, MAX_LAYOUT_CHAIN_DEPTH)\n  for (const [index, layoutNodes] of chain.entries()) {\n    composed = composeLayoutAndScreenNodes(layoutNodes, composed, index + 1)\n  }\n  return composed\n}\n\n/**\n * Walks a layout's ancestry into a flat chain, innermost first (AGL-703).\n *\n * `parentOf` returns the layout a given layout renders inside, or undefined\n * at the top. The walk stops on:\n *\n * - **self-reference** — a layout naming itself, which is the case worth\n *   naming out loud because it is the easy mistake to make;\n * - **any repeat** — A → B → A would otherwise recurse forever, and a\n *   guard that only catches self-reference would miss it;\n * - **depth** — {@link MAX_LAYOUT_CHAIN_DEPTH}.\n *\n * Stopping (rather than throwing) is deliberate: a cycle in stored data\n * should render the layouts up to the repeat, not blank the site.\n */\nexport function resolveLayoutChainIds(\n  layoutId: string | undefined | null,\n  parentOf: (layoutId: string) => string | undefined | null,\n): string[] {\n  const chain: string[] = []\n  const seen = new Set<string>()\n  let current = layoutId ? String(layoutId) : undefined\n  while (current && !seen.has(current) && chain.length < MAX_LAYOUT_CHAIN_DEPTH) {\n    chain.push(current)\n    seen.add(current)\n    const parent = parentOf(current)\n    current = parent ? String(parent) : undefined\n  }\n  return chain\n}\n\n/**\n * Whether `candidateParentId` may be set as `layoutId`'s parent layout.\n *\n * Refuses self-reference and any candidate that already has this layout\n * somewhere above it — picking one would close a loop. This is the\n * write-time half; `resolveLayoutChainIds` stays defensive anyway, because\n * a document can be edited by something that never called this.\n */\nexport function canNestLayout(\n  layoutId: string,\n  candidateParentId: string,\n  parentOf: (layoutId: string) => string | undefined | null,\n): boolean {\n  if (!layoutId || !candidateParentId) return false\n  if (layoutId === candidateParentId) return false\n  return !resolveLayoutChainIds(candidateParentId, parentOf).includes(layoutId)\n}\n\nexport default composeLayoutAndScreenNodes\n"],"names":["NODE_ROOT_ID","COMPONENT_NODE_ID_PREFIX","mergeNodeSx","LAYOUT_SLOT_COMPONENT_ID","LAYOUT_NODE_ID_PREFIX","MAX_LAYOUT_CHAIN_DEPTH","layoutNodeIdPrefix","depth","LAYOUT_NODE_ID_PREFIXES","Array","from","length","_unused","index","isLayoutComposedNodeId","id","value","String","startsWith","slice","some","prefix","hasScreenAuthoredNodes","nodes","Object","keys","prefixLayoutId","prefixChildIds","isArray","map","composeLayoutAndScreenNodes","layoutNodes","screenNodes","composed","slotEntry","entries","find","node","componentId","nextId","$id","parentId","slotId","screenRoot","screenRootChildIds","slotChildIds","mergedSlotSx","sx","classNameOf","className","mergedSlotClassName","filter","Boolean","join","undefined","isTopLevel","childId","composeLayoutChainAndScreenNodes","layoutNodesChain","chain","resolveLayoutChainIds","layoutId","parentOf","seen","Set","current","has","push","add","parent","canNestLayout","candidateParentId","includes"],"mappings":"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"}

package/src/lib/app-utils/compose-layout-props.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { AglynNodeSchema, NodeId, ReusableComponentProp } from '../foundation';
+/**
+ * Layout properties (AGL-2893): a shared layout declares properties exactly as
+ * a reusable component does, binds its own nodes to them with `{{prop.*}}`,
+ * and each screen rendering inside it sets the values.
+ *
+ * The values are applied to each layout's OWN nodes before the screen is
+ * grafted into its slot, so a `{{prop.*}}` the screen's own copy happens to
+ * contain is never touched, and a component the layout places receives the
+ * values it is handed before it is grafted.
+ */
+type NormalizedNodes<N extends AglynNodeSchema> = Record<NodeId, N>;
+/**
+ * Screen-version key holding the screen's values for the layouts it renders
+ * inside, beside the `layoutId` binding. Persisted in screen version documents
+ * — never rename.
+ */
+export declare const SCREEN_LAYOUT_PROP_VALUES_KEY = "layoutPropValues";
+/** One layout of a screen's chain, as composition reads it. */
+export interface LayoutChainEntry<N extends AglynNodeSchema = AglynNodeSchema> {
+    /** The layout document's id, which a screen's values are keyed by. */
+    layoutId?: string | null;
+    /** The published version's nodes. */
+    nodes?: NormalizedNodes<N> | null;
+    /** The published version's declared properties. */
+    props?: ReusableComponentProp[] | null;
+}
+/**
+ * A screen's values for one layout of its chain, or `undefined` where it set
+ * none. Anything that is not a map of values is read as none.
+ */
+export declare function layoutPropValuesFor(layoutPropValues: unknown, layoutId: string | null | undefined): Record<string, unknown> | undefined;
+/**
+ * A layout's nodes with its declared properties applied for one screen: each
+ * `{{prop.*}}` takes the screen's value or the property's default, a field
+ * bound to one property receives the value its kind holds, and the parts the
+ * screen hides (`hideIf` / `hideUnless`) are pruned — the sequence a reusable
+ * component's graft runs, over the layout's root.
+ *
+ * A layout with no root is returned as it is, for the reason
+ * `composeLayoutAndScreenNodes` gives: a broken layout degrades to the bare
+ * screen rather than taking a page down.
+ */
+export declare function applyLayoutProps<N extends AglynNodeSchema = AglynNodeSchema>(nodes: NormalizedNodes<N> | null | undefined, props: ReusableComponentProp[] | null | undefined, values: Readonly<Record<string, unknown>> | null | undefined): NormalizedNodes<N> | undefined;
+/**
+ * A screen grafted through its whole layout chain, innermost first, with each
+ * layout's properties applied from the screen's values for that layout
+ * (`layoutPropValues`, keyed by layout id).
+ *
+ * The one composition the published page, the besigner's Preview and its
+ * layout chrome all run, so none of them can disagree about which value a
+ * layout renders with.
+ */
+export declare function composeLayoutChainWithProps<N extends AglynNodeSchema = AglynNodeSchema>(chain: ReadonlyArray<LayoutChainEntry<N> | null | undefined>, screenNodes: NormalizedNodes<N>, layoutPropValues?: unknown): NormalizedNodes<N>;
+export default composeLayoutChainWithProps;

package/src/lib/app-utils/compose-layout-props.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { NODE_ROOT_ID } from "../canvas-manager/canvas-manager.js";
+import { composeLayoutChainAndScreenNodes } from "./compose-layout-nodes.js";
+import { applyDeclaredProps } from "./compose-reusable-components.js";
+/**
+ * Screen-version key holding the screen's values for the layouts it renders
+ * inside, beside the `layoutId` binding. Persisted in screen version documents
+ * — never rename.
+ */ export const SCREEN_LAYOUT_PROP_VALUES_KEY = 'layoutPropValues';
+/**
+ * A screen's values for one layout of its chain, or `undefined` where it set
+ * none. Anything that is not a map of values is read as none.
+ */ export function layoutPropValuesFor(layoutPropValues, layoutId) {
+    if (!layoutId || !layoutPropValues || typeof layoutPropValues !== 'object') {
+        return undefined;
+    }
+    const values = layoutPropValues[layoutId];
+    return values && typeof values === 'object' && !Array.isArray(values) ? values : undefined;
+}
+/**
+ * A layout's nodes with its declared properties applied for one screen: each
+ * `{{prop.*}}` takes the screen's value or the property's default, a field
+ * bound to one property receives the value its kind holds, and the parts the
+ * screen hides (`hideIf` / `hideUnless`) are pruned — the sequence a reusable
+ * component's graft runs, over the layout's root.
+ *
+ * A layout with no root is returned as it is, for the reason
+ * `composeLayoutAndScreenNodes` gives: a broken layout degrades to the bare
+ * screen rather than taking a page down.
+ */ export function applyLayoutProps(nodes, props, values) {
+    if (!nodes || !nodes[NODE_ROOT_ID]) return nodes != null ? nodes : undefined;
+    return applyDeclaredProps(nodes, props, values, NODE_ROOT_ID);
+}
+/**
+ * A screen grafted through its whole layout chain, innermost first, with each
+ * layout's properties applied from the screen's values for that layout
+ * (`layoutPropValues`, keyed by layout id).
+ *
+ * The one composition the published page, the besigner's Preview and its
+ * layout chrome all run, so none of them can disagree about which value a
+ * layout renders with.
+ */ export function composeLayoutChainWithProps(chain, screenNodes, layoutPropValues) {
+    return composeLayoutChainAndScreenNodes(chain.map((entry)=>applyLayoutProps(entry == null ? void 0 : entry.nodes, entry == null ? void 0 : entry.props, layoutPropValuesFor(layoutPropValues, entry == null ? void 0 : entry.layoutId))), screenNodes);
+}
+export default composeLayoutChainWithProps;
+
+//# sourceMappingURL=compose-layout-props.js.map

package/src/lib/app-utils/compose-layout-props.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/compose-layout-props.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type {\n  AglynNodeSchema,\n  NodeId,\n  ReusableComponentProp,\n} from '../foundation'\nimport { NODE_ROOT_ID } from '../canvas-manager/canvas-manager'\nimport { composeLayoutChainAndScreenNodes } from './compose-layout-nodes'\nimport { applyDeclaredProps } from './compose-reusable-components'\n\n/**\n * Layout properties (AGL-2893): a shared layout declares properties exactly as\n * a reusable component does, binds its own nodes to them with `{{prop.*}}`,\n * and each screen rendering inside it sets the values.\n *\n * The values are applied to each layout's OWN nodes before the screen is\n * grafted into its slot, so a `{{prop.*}}` the screen's own copy happens to\n * contain is never touched, and a component the layout places receives the\n * values it is handed before it is grafted.\n */\n\ntype NormalizedNodes<N extends AglynNodeSchema> = Record<NodeId, N>\n\n/**\n * Screen-version key holding the screen's values for the layouts it renders\n * inside, beside the `layoutId` binding. Persisted in screen version documents\n * — never rename.\n */\nexport const SCREEN_LAYOUT_PROP_VALUES_KEY = 'layoutPropValues'\n\n/** One layout of a screen's chain, as composition reads it. */\nexport interface LayoutChainEntry<N extends AglynNodeSchema = AglynNodeSchema> {\n  /** The layout document's id, which a screen's values are keyed by. */\n  layoutId?: string | null\n  /** The published version's nodes. */\n  nodes?: NormalizedNodes<N> | null\n  /** The published version's declared properties. */\n  props?: ReusableComponentProp[] | null\n}\n\n/**\n * A screen's values for one layout of its chain, or `undefined` where it set\n * none. Anything that is not a map of values is read as none.\n */\nexport function layoutPropValuesFor(\n  layoutPropValues: unknown,\n  layoutId: string | null | undefined,\n): Record<string, unknown> | undefined {\n  if (!layoutId || !layoutPropValues || typeof layoutPropValues !== 'object') {\n    return undefined\n  }\n  const values = (layoutPropValues as Record<string, unknown>)[layoutId]\n  return values && typeof values === 'object' && !Array.isArray(values)\n    ? (values as Record<string, unknown>)\n    : undefined\n}\n\n/**\n * A layout's nodes with its declared properties applied for one screen: each\n * `{{prop.*}}` takes the screen's value or the property's default, a field\n * bound to one property receives the value its kind holds, and the parts the\n * screen hides (`hideIf` / `hideUnless`) are pruned — the sequence a reusable\n * component's graft runs, over the layout's root.\n *\n * A layout with no root is returned as it is, for the reason\n * `composeLayoutAndScreenNodes` gives: a broken layout degrades to the bare\n * screen rather than taking a page down.\n */\nexport function applyLayoutProps<N extends AglynNodeSchema = AglynNodeSchema>(\n  nodes: NormalizedNodes<N> | null | undefined,\n  props: ReusableComponentProp[] | null | undefined,\n  values: Readonly<Record<string, unknown>> | null | undefined,\n): NormalizedNodes<N> | undefined {\n  if (!nodes || !nodes[NODE_ROOT_ID]) return nodes ?? undefined\n  return applyDeclaredProps(nodes, props, values, NODE_ROOT_ID)\n}\n\n/**\n * A screen grafted through its whole layout chain, innermost first, with each\n * layout's properties applied from the screen's values for that layout\n * (`layoutPropValues`, keyed by layout id).\n *\n * The one composition the published page, the besigner's Preview and its\n * layout chrome all run, so none of them can disagree about which value a\n * layout renders with.\n */\nexport function composeLayoutChainWithProps<\n  N extends AglynNodeSchema = AglynNodeSchema,\n>(\n  chain: ReadonlyArray<LayoutChainEntry<N> | null | undefined>,\n  screenNodes: NormalizedNodes<N>,\n  layoutPropValues?: unknown,\n): NormalizedNodes<N> {\n  return composeLayoutChainAndScreenNodes(\n    chain.map((entry) =>\n      applyLayoutProps(\n        entry?.nodes,\n        entry?.props,\n        layoutPropValuesFor(layoutPropValues, entry?.layoutId),\n      ),\n    ),\n    screenNodes,\n  )\n}\n\nexport default composeLayoutChainWithProps\n"],"names":["NODE_ROOT_ID","composeLayoutChainAndScreenNodes","applyDeclaredProps","SCREEN_LAYOUT_PROP_VALUES_KEY","layoutPropValuesFor","layoutPropValues","layoutId","undefined","values","Array","isArray","applyLayoutProps","nodes","props","composeLayoutChainWithProps","chain","screenNodes","map","entry"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAOD,SAASA,YAAY,QAAQ,sCAAkC;AAC/D,SAASC,gCAAgC,QAAQ,4BAAwB;AACzE,SAASC,kBAAkB,QAAQ,mCAA+B;AAelE;;;;CAIC,GACD,OAAO,MAAMC,gCAAgC,mBAAkB;AAY/D;;;CAGC,GACD,OAAO,SAASC,oBACdC,gBAAyB,EACzBC,QAAmC;IAEnC,IAAI,CAACA,YAAY,CAACD,oBAAoB,OAAOA,qBAAqB,UAAU;QAC1E,OAAOE;IACT;IACA,MAAMC,SAAS,AAACH,gBAA4C,CAACC,SAAS;IACtE,OAAOE,UAAU,OAAOA,WAAW,YAAY,CAACC,MAAMC,OAAO,CAACF,UACzDA,SACDD;AACN;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASI,iBACdC,KAA4C,EAC5CC,KAAiD,EACjDL,MAA4D;IAE5D,IAAI,CAACI,SAAS,CAACA,KAAK,CAACZ,aAAa,EAAE,OAAOY,gBAAAA,QAASL;IACpD,OAAOL,mBAAmBU,OAAOC,OAAOL,QAAQR;AAClD;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASc,4BAGdC,KAA4D,EAC5DC,WAA+B,EAC/BX,gBAA0B;IAE1B,OAAOJ,iCACLc,MAAME,GAAG,CAAC,CAACC,QACTP,iBACEO,yBAAAA,MAAON,KAAK,EACZM,yBAAAA,MAAOL,KAAK,EACZT,oBAAoBC,kBAAkBa,yBAAAA,MAAOZ,QAAQ,KAGzDU;AAEJ;AAEA,eAAeF,4BAA2B"}