@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/expand-repeatables.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @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 } from '../foundation';
+/** Namespaces cloned template ids per container/record. */
+export declare const REPEAT_NODE_ID_PREFIX = "rep__";
+/** Hard bound on rows a single repeatable renders, before `repeatLimit`. */
+export declare const REPEAT_MAX_RECORDS = 100;
+export interface RepeatableDataset {
+    /**
+     * Row value maps, in display order. Rows carry `$id` (needed to resolve
+     * incoming references); values may be typed (AGL-177), stringified at
+     * substitution.
+     */
+    records: Array<Record<string, unknown>>;
+    /** Typed model (AGL-177); required for reference-hop bindings. */
+    model?: import('./dataset-models').DatasetModel;
+}
+/**
+ * The key a node repeats over, trimmed, or `''` when it repeats over nothing.
+ *
+ * The one predicate every repeat question is asked through: the expansion, the
+ * datasets-read gate below, the reusable-component graft that moves a
+ * placement's repeat onto the element it becomes, and the besigner's preview
+ * and badge. Two copies of it are how a `.trim()` on one side and not the
+ * other becomes an empty list on a customer's page.
+ */
+export declare const repeatKey: (node: unknown) => string;
+/**
+ * Makes an element that holds children repeat ITSELF, once per record, instead
+ * of what is inside it (AGL-3111): a card whose contents are the design, rather
+ * than a list whose contents are the item.
+ *
+ * Persisted in screen, layout and component documents — never rename. `'true'`
+ * counts too, because a switch round-tripped through a text-shaped store comes
+ * back as the string.
+ */
+export declare const REPEAT_SELF_PROP = "repeatSelf";
+/**
+ * Every prop that directs a repeat. They are instructions to the composition,
+ * never attributes of the element: the expansion consumes them from every node
+ * it expands and every copy it makes, so a published element never carries
+ * one. Persisted — never rename.
+ */
+export declare const REPEAT_DIRECTIVE_PROPS: readonly string[];
+/**
+ * What a repeating node copies once per record (AGL-3111).
+ *
+ * - `children` — what is inside it. The node stays one element around the
+ *   copies: the list, grid or gallery they fill. This is how a Stack has
+ *   always repeated (AGL-103), and a stored Stack names neither scope.
+ * - `self` — the node itself, with everything inside it. What a leaf and a
+ *   component instance repeat, and what any element carrying
+ *   {@link REPEAT_SELF_PROP} repeats.
+ */
+export type RepeatScope = 'self' | 'children';
+/**
+ * Which scope a repeating node has, read off the node alone so the published
+ * page's composition and the besigner decide it identically.
+ *
+ * {@link REPEAT_SELF_PROP} decides it whenever the node carries one, which is
+ * every repeat the Attributes panel writes. Without one the node's own shape
+ * decides, and it decides CONSERVATIVELY: anything that holds a child list —
+ * a Stack, empty or not — keeps repeating its children, and only a node with
+ * no child list at all repeats itself. A stored repeat predates the prop, so
+ * this branch is the one that has to render it unchanged, and an author who
+ * named a dataset before filling the container in would otherwise come back to
+ * a hundred empty copies of it.
+ *
+ * A component instance never reaches that branch: the graft stamps the prop on
+ * the element it becomes, whose children are the component's own.
+ */
+export declare function repeatScope(node: unknown): RepeatScope;
+/**
+ * One record's values put into `{{item.field}}` tokens, anywhere in a props
+ * map — the substitution {@link expandRepeatables} makes on every copy it
+ * builds, for a caller that already knows which record it is rendering.
+ *
+ * The besigner's canvas is that caller (AGL-3111): the element an author
+ * edits IS the first copy, so it draws with the first record's values while
+ * the node it saves keeps the tokens. Exported rather than reimplemented
+ * because a canvas that resolved a token differently from the page would be
+ * showing the author a page that does not exist.
+ */
+export declare function substituteRecordTokens<T>(props: T, context: {
+    record: Record<string, unknown>;
+    /** Model of the repeated rows; reference hops need field configs. */
+    model?: import('./dataset-models').DatasetModel;
+    /** Rows by key, for a one-hop reference (AGL-180). */
+    datasetsByKey?: Record<string, RepeatableDataset | undefined>;
+}): T;
+/** The node minus its repeat directives, or the node itself when it has none. */
+export declare function withoutRepeatDirective<N>(node: N): N;
+/**
+ * The records a repeating node renders, in order (AGL-181): its filter and sort
+ * evaluated over the rows, then its limit, never past
+ * {@link REPEAT_MAX_RECORDS}. An unparseable filter or sort fails open.
+ *
+ * Shared by the expansion and the besigner's canvas preview and badge, so the
+ * canvas can never show a copy or a count the published page does not.
+ */
+export declare function repeatedRecords(node: unknown, dataset: RepeatableDataset | undefined): Array<Record<string, unknown>>;
+/**
+ * Does this tree contain anything {@link expandRepeatables} would expand?
+ *
+ * The datasets read is the largest on the render path — up to two pages of
+ * {@link REPEAT_MAX_RECORDS} records for every dataset a page repeats over —
+ * and a page that repeats over nothing should pay none of it (AGL-1440).
+ *
+ * Any gate on that read has to ask EXACTLY the question the expansion asks,
+ * which is why this and {@link repeatDatasetKeys} share the one predicate
+ * `expandRepeatables` looks keys up with, {@link repeatKey}. A gate that is
+ * even slightly stricter than the expansion is not a saving: it is a published
+ * page that quietly renders one template row where the author put a list.
+ */
+export declare function hasRepeatableNodes(nodes: Record<NodeId, unknown> | null | undefined): boolean;
+/**
+ * Every dataset key this tree repeats over — a dataset id or a display name,
+ * exactly as {@link expandRepeatables} looks it up — sorted and without
+ * repeats.
+ *
+ * What the tenant compose reads, so a page loads the datasets it renders and
+ * not every dataset its site may see. Built on the same predicate as
+ * {@link hasRepeatableNodes} for the reason given there.
+ */
+export declare function repeatDatasetKeys(nodes: Record<NodeId, unknown> | null | undefined): string[];
+/**
+ * Repeats (AGL-103, AGL-3111): any node carrying `props.repeatDataset` (a
+ * dataset id or display name) renders once per record of that dataset, with
+ * `{{item.field}}` tokens in the copied string props replaced by the record's
+ * values (unknown fields keep the literal token, like variable bindings).
+ *
+ * What is copied is the node's {@link repeatScope}:
+ *
+ * - `children` — its children are the item template. The node stays, and its
+ *   child list becomes the copies, record by record. Its own props are not the
+ *   template, so no token in them is substituted.
+ * - `self` — the node and everything inside it are the template. The copies
+ *   take the node's place in its parent's child list, and every prop in the
+ *   subtree is substituted, the node's own included.
+ *
+ * - Copy ids are namespaced `rep__{repeatId}__{index}__…` — the repeat's own
+ *   id, then the template node's — so repeats never collide, including inside
+ *   grafted reusable components. A self-scoped node's first copy is
+ *   `rep__{id}__0__{id}`. Run this AFTER `composeReusableComponentNodes` and
+ *   BEFORE binding resolution.
+ * - Rows are the node's {@link repeatedRecords}.
+ * - The repeat directives ({@link REPEAT_DIRECTIVE_PROPS}) are consumed: every
+ *   node this expands, and every copy it makes, comes out without them.
+ * - Repeats do not nest. A repeat inside another repeat's template is copied
+ *   with its directives consumed, so it renders once in each copy.
+ * - An unknown dataset, no matching records, an empty template, or a
+ *   self-scoped node its parent does not list (the document root, say) leave
+ *   the node rendering once, as written (fail-open: a deleted dataset must
+ *   never take a published screen down).
+ * - Inputs are never mutated; templates stay in the map unreferenced.
+ */
+export declare function expandRepeatables<N extends AglynNodeSchema = AglynNodeSchema>(nodes: Record<NodeId, N>, datasetsByKey: Record<string, RepeatableDataset | undefined> | undefined): Record<NodeId, N>;
+export default expandRepeatables;

package/src/lib/app-utils/expand-repeatables.js

@@ -0,0 +1,299 @@
+/**
+ * @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 { applyDatasetQuery, parseDatasetFilter, parseDatasetSort } from "./dataset-query.js";
+/** Namespaces cloned template ids per container/record. */ export const REPEAT_NODE_ID_PREFIX = 'rep__';
+/**
+ * `{{item.field}}` token, plus an optional single reference hop
+ * (`{{item.author.name}}`, AGL-180). One hop only — the pattern itself is
+ * the depth guard, so cycles can't recurse.
+ */ const ITEM_TOKEN_PATTERN = /\{\{\s*item\.([A-Za-z][A-Za-z0-9_]*)(?:\.([A-Za-z][A-Za-z0-9_]*))?\s*\}\}/g;
+/** Hard bound on rows a single repeatable renders, before `repeatLimit`. */ export const REPEAT_MAX_RECORDS = 100;
+const displayValue = (value)=>Array.isArray(value) ? value.join(', ') : String(value);
+/** Resolves `{{item.ref.field}}`: FKey(s) → target document field value. */ function resolveReferenceHop(context, fieldId, targetFieldId) {
+    var _context_model_fields, _context_model, _field_reference, _context_datasetsByKey;
+    const field = (_context_model = context.model) == null ? void 0 : (_context_model_fields = _context_model.fields) == null ? void 0 : _context_model_fields[fieldId];
+    if ((field == null ? void 0 : field.type) !== 'reference' || !((_field_reference = field.reference) == null ? void 0 : _field_reference.datasetId)) return null;
+    const target = (_context_datasetsByKey = context.datasetsByKey) == null ? void 0 : _context_datasetsByKey[field.reference.datasetId];
+    if (!target) return null;
+    const keys = context.record[fieldId];
+    const ids = Array.isArray(keys) ? keys : keys != null ? [
+        keys
+    ] : [];
+    const resolved = ids.map((id)=>{
+        const match = target.records.find((row)=>row['$id'] === id);
+        const value = match == null ? void 0 : match[targetFieldId];
+        return value != null ? displayValue(value) : null;
+    }).filter((value)=>value != null);
+    return resolved.length ? resolved.join(', ') : null;
+}
+function substituteValue(value, context) {
+    const { record } = context;
+    if (typeof value === 'string') {
+        return value.replace(ITEM_TOKEN_PATTERN, (token, field, hop)=>{
+            if (hop) {
+                const resolved = resolveReferenceHop(context, field, hop);
+                return resolved != null ? resolved : token;
+            }
+            return record[field] != null ? displayValue(record[field]) : token;
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry)=>substituteValue(entry, context));
+    }
+    if (value && typeof value === 'object') {
+        const next = {};
+        for (const [key, entry] of Object.entries(value)){
+            next[key] = substituteValue(entry, context);
+        }
+        return next;
+    }
+    return value;
+}
+/**
+ * The key a node repeats over, trimmed, or `''` when it repeats over nothing.
+ *
+ * The one predicate every repeat question is asked through: the expansion, the
+ * datasets-read gate below, the reusable-component graft that moves a
+ * placement's repeat onto the element it becomes, and the besigner's preview
+ * and badge. Two copies of it are how a `.trim()` on one side and not the
+ * other becomes an empty list on a customer's page.
+ */ export const repeatKey = (node)=>{
+    var _node_props;
+    const key = node == null ? void 0 : (_node_props = node.props) == null ? void 0 : _node_props.repeatDataset;
+    return typeof key === 'string' ? key.trim() : '';
+};
+/**
+ * Makes an element that holds children repeat ITSELF, once per record, instead
+ * of what is inside it (AGL-3111): a card whose contents are the design, rather
+ * than a list whose contents are the item.
+ *
+ * Persisted in screen, layout and component documents — never rename. `'true'`
+ * counts too, because a switch round-tripped through a text-shaped store comes
+ * back as the string.
+ */ export const REPEAT_SELF_PROP = 'repeatSelf';
+/**
+ * Every prop that directs a repeat. They are instructions to the composition,
+ * never attributes of the element: the expansion consumes them from every node
+ * it expands and every copy it makes, so a published element never carries
+ * one. Persisted — never rename.
+ */ export const REPEAT_DIRECTIVE_PROPS = [
+    'repeatDataset',
+    'repeatLimit',
+    'repeatFilter',
+    'repeatSort',
+    REPEAT_SELF_PROP
+];
+/**
+ * Which scope a repeating node has, read off the node alone so the published
+ * page's composition and the besigner decide it identically.
+ *
+ * {@link REPEAT_SELF_PROP} decides it whenever the node carries one, which is
+ * every repeat the Attributes panel writes. Without one the node's own shape
+ * decides, and it decides CONSERVATIVELY: anything that holds a child list —
+ * a Stack, empty or not — keeps repeating its children, and only a node with
+ * no child list at all repeats itself. A stored repeat predates the prop, so
+ * this branch is the one that has to render it unchanged, and an author who
+ * named a dataset before filling the container in would otherwise come back to
+ * a hundred empty copies of it.
+ *
+ * A component instance never reaches that branch: the graft stamps the prop on
+ * the element it becomes, whose children are the component's own.
+ */ export function repeatScope(node) {
+    const { props, nodes } = node != null ? node : {};
+    // `'true'`/`'false'` too: a switch round-tripped through a text-shaped
+    // store comes back as the string it was written as.
+    const self = props == null ? void 0 : props[REPEAT_SELF_PROP];
+    if (self === true || self === 'true') return 'self';
+    if (self === false || self === 'false') return 'children';
+    return Array.isArray(nodes) ? 'children' : 'self';
+}
+/**
+ * One record's values put into `{{item.field}}` tokens, anywhere in a props
+ * map — the substitution {@link expandRepeatables} makes on every copy it
+ * builds, for a caller that already knows which record it is rendering.
+ *
+ * The besigner's canvas is that caller (AGL-3111): the element an author
+ * edits IS the first copy, so it draws with the first record's values while
+ * the node it saves keeps the tokens. Exported rather than reimplemented
+ * because a canvas that resolved a token differently from the page would be
+ * showing the author a page that does not exist.
+ */ export function substituteRecordTokens(props, context) {
+    return substituteValue(props, context);
+}
+/** The node minus its repeat directives, or the node itself when it has none. */ export function withoutRepeatDirective(node) {
+    const props = node == null ? void 0 : node.props;
+    if (!props || !REPEAT_DIRECTIVE_PROPS.some((key)=>key in props)) {
+        return node;
+    }
+    const kept = _extends({}, props);
+    for (const key of REPEAT_DIRECTIVE_PROPS)delete kept[key];
+    return _extends({}, node, {
+        props: kept
+    });
+}
+/**
+ * The records a repeating node renders, in order (AGL-181): its filter and sort
+ * evaluated over the rows, then its limit, never past
+ * {@link REPEAT_MAX_RECORDS}. An unparseable filter or sort fails open.
+ *
+ * Shared by the expansion and the besigner's canvas preview and badge, so the
+ * canvas can never show a copy or a count the published page does not.
+ */ export function repeatedRecords(node, dataset) {
+    var _ref, _props_repeatFilter, _props_repeatSort, _ref1;
+    const props = (_ref = node == null ? void 0 : node.props) != null ? _ref : {};
+    const where = parseDatasetFilter(String((_props_repeatFilter = props['repeatFilter']) != null ? _props_repeatFilter : ''));
+    const orderBy = parseDatasetSort(String((_props_repeatSort = props['repeatSort']) != null ? _props_repeatSort : ''));
+    const limit = Number(props['repeatLimit']);
+    return applyDatasetQuery(dataset == null ? void 0 : dataset.model, (_ref1 = dataset == null ? void 0 : dataset.records) != null ? _ref1 : [], _extends({}, where ? {
+        where: [
+            where
+        ]
+    } : {}, orderBy ? {
+        orderBy
+    } : {})).slice(0, Number.isFinite(limit) && limit > 0 ? Math.min(limit, REPEAT_MAX_RECORDS) : REPEAT_MAX_RECORDS);
+}
+/**
+ * Does this tree contain anything {@link expandRepeatables} would expand?
+ *
+ * The datasets read is the largest on the render path — up to two pages of
+ * {@link REPEAT_MAX_RECORDS} records for every dataset a page repeats over —
+ * and a page that repeats over nothing should pay none of it (AGL-1440).
+ *
+ * Any gate on that read has to ask EXACTLY the question the expansion asks,
+ * which is why this and {@link repeatDatasetKeys} share the one predicate
+ * `expandRepeatables` looks keys up with, {@link repeatKey}. A gate that is
+ * even slightly stricter than the expansion is not a saving: it is a published
+ * page that quietly renders one template row where the author put a list.
+ */ export function hasRepeatableNodes(nodes) {
+    if (!nodes) return false;
+    return Object.values(nodes).some((node)=>repeatKey(node) !== '');
+}
+/**
+ * Every dataset key this tree repeats over — a dataset id or a display name,
+ * exactly as {@link expandRepeatables} looks it up — sorted and without
+ * repeats.
+ *
+ * What the tenant compose reads, so a page loads the datasets it renders and
+ * not every dataset its site may see. Built on the same predicate as
+ * {@link hasRepeatableNodes} for the reason given there.
+ */ export function repeatDatasetKeys(nodes) {
+    const keys = new Set();
+    for (const node of Object.values(nodes != null ? nodes : {})){
+        const key = repeatKey(node);
+        if (key) keys.add(key);
+    }
+    return [
+        ...keys
+    ].sort();
+}
+/**
+ * Repeats (AGL-103, AGL-3111): any node carrying `props.repeatDataset` (a
+ * dataset id or display name) renders once per record of that dataset, with
+ * `{{item.field}}` tokens in the copied string props replaced by the record's
+ * values (unknown fields keep the literal token, like variable bindings).
+ *
+ * What is copied is the node's {@link repeatScope}:
+ *
+ * - `children` — its children are the item template. The node stays, and its
+ *   child list becomes the copies, record by record. Its own props are not the
+ *   template, so no token in them is substituted.
+ * - `self` — the node and everything inside it are the template. The copies
+ *   take the node's place in its parent's child list, and every prop in the
+ *   subtree is substituted, the node's own included.
+ *
+ * - Copy ids are namespaced `rep__{repeatId}__{index}__…` — the repeat's own
+ *   id, then the template node's — so repeats never collide, including inside
+ *   grafted reusable components. A self-scoped node's first copy is
+ *   `rep__{id}__0__{id}`. Run this AFTER `composeReusableComponentNodes` and
+ *   BEFORE binding resolution.
+ * - Rows are the node's {@link repeatedRecords}.
+ * - The repeat directives ({@link REPEAT_DIRECTIVE_PROPS}) are consumed: every
+ *   node this expands, and every copy it makes, comes out without them.
+ * - Repeats do not nest. A repeat inside another repeat's template is copied
+ *   with its directives consumed, so it renders once in each copy.
+ * - An unknown dataset, no matching records, an empty template, or a
+ *   self-scoped node its parent does not list (the document root, say) leave
+ *   the node rendering once, as written (fail-open: a deleted dataset must
+ *   never take a published screen down).
+ * - Inputs are never mutated; templates stay in the map unreferenced.
+ */ export function expandRepeatables(nodes, datasetsByKey) {
+    if (!datasetsByKey) return nodes;
+    const repeatIds = Object.entries(nodes).filter(([, node])=>repeatKey(node) !== '');
+    if (!repeatIds.length) return nodes;
+    const next = _extends({}, nodes);
+    for (const [repeatId, repeated] of repeatIds){
+        var _next_parentId;
+        const dataset = datasetsByKey[repeatKey(repeated)];
+        const records = repeatedRecords(repeated, dataset);
+        const self = repeatScope(repeated) === 'self';
+        // The copies' parent: the node itself, or — for a self-scoped node — the
+        // parent whose child list the copies take its place in, read from `next`
+        // so two self-scoped siblings both land in the list the other has left.
+        const parentId = self ? repeated.parentId : repeatId;
+        const siblings = (_next_parentId = next[parentId]) == null ? void 0 : _next_parentId.nodes;
+        const slot = Array.isArray(siblings) ? siblings.indexOf(repeatId) : -1;
+        const templateIds = self ? [
+            repeatId
+        ] : Array.isArray(repeated.nodes) ? repeated.nodes : [];
+        next[repeatId] = withoutRepeatDirective(next[repeatId]);
+        if (!records.length || !templateIds.length || self && slot < 0) continue;
+        const copyIds = [];
+        records.forEach((record, index)=>{
+            const prefix = `${REPEAT_NODE_ID_PREFIX}${repeatId}__${index}__`;
+            const prefixId = (id)=>`${prefix}${id}`;
+            const cloneSubtree = (id, clonedParentId)=>{
+                var _node_props;
+                const node = nodes[id];
+                if (!node) return;
+                const clonedChildren = Array.isArray(node.nodes) ? node.nodes : undefined;
+                next[prefixId(id)] = withoutRepeatDirective(_extends({}, node, {
+                    $id: prefixId(id),
+                    parentId: clonedParentId,
+                    props: substituteValue((_node_props = node.props) != null ? _node_props : {}, {
+                        record,
+                        model: dataset == null ? void 0 : dataset.model,
+                        datasetsByKey
+                    })
+                }, clonedChildren && {
+                    nodes: clonedChildren.map((childId)=>prefixId(childId))
+                }));
+                clonedChildren == null ? void 0 : clonedChildren.forEach((childId)=>cloneSubtree(childId, prefixId(id)));
+            };
+            for (const templateId of templateIds){
+                cloneSubtree(templateId, parentId);
+                copyIds.push(prefixId(templateId));
+            }
+        });
+        if (self) {
+            const listed = [
+                ...next[parentId].nodes
+            ];
+            listed.splice(slot, 1, ...copyIds);
+            next[parentId] = _extends({}, next[parentId], {
+                nodes: listed
+            });
+        } else {
+            next[repeatId] = _extends({}, next[repeatId], {
+                nodes: copyIds
+            });
+        }
+    }
+    return next;
+}
+export default expandRepeatables;
+
+//# sourceMappingURL=expand-repeatables.js.map

package/src/lib/app-utils/expand-repeatables.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/expand-repeatables.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 {\n  applyDatasetQuery,\n  parseDatasetFilter,\n  parseDatasetSort,\n} from './dataset-query'\n\n/** Namespaces cloned template ids per container/record. */\nexport const REPEAT_NODE_ID_PREFIX = 'rep__'\n\n/**\n * `{{item.field}}` token, plus an optional single reference hop\n * (`{{item.author.name}}`, AGL-180). One hop only — the pattern itself is\n * the depth guard, so cycles can't recurse.\n */\nconst ITEM_TOKEN_PATTERN =\n  /\\{\\{\\s*item\\.([A-Za-z][A-Za-z0-9_]*)(?:\\.([A-Za-z][A-Za-z0-9_]*))?\\s*\\}\\}/g\n\n/** Hard bound on rows a single repeatable renders, before `repeatLimit`. */\nexport const REPEAT_MAX_RECORDS = 100\n\nexport interface RepeatableDataset {\n  /**\n   * Row value maps, in display order. Rows carry `$id` (needed to resolve\n   * incoming references); values may be typed (AGL-177), stringified at\n   * substitution.\n   */\n  records: Array<Record<string, unknown>>\n  /** Typed model (AGL-177); required for reference-hop bindings. */\n  model?: import('./dataset-models').DatasetModel\n}\n\ninterface SubstituteContext {\n  record: Record<string, unknown>\n  /** Model of the repeated dataset (reference hops need field configs). */\n  model?: import('./dataset-models').DatasetModel\n  /** All host datasets keyed by id (and name) for hop resolution. */\n  datasetsByKey?: Record<string, RepeatableDataset | undefined>\n}\n\nconst displayValue = (value: unknown): string =>\n  Array.isArray(value) ? value.join(', ') : String(value)\n\n/** Resolves `{{item.ref.field}}`: FKey(s) → target document field value. */\nfunction resolveReferenceHop(\n  context: SubstituteContext,\n  fieldId: string,\n  targetFieldId: string,\n): string | null {\n  const field = context.model?.fields?.[fieldId]\n  if (field?.type !== 'reference' || !field.reference?.datasetId) return null\n  const target = context.datasetsByKey?.[field.reference.datasetId]\n  if (!target) return null\n  const keys = context.record[fieldId]\n  const ids = Array.isArray(keys) ? keys : keys != null ? [keys] : []\n  const resolved = ids\n    .map((id) => {\n      const match = target.records.find((row) => row['$id'] === id)\n      const value = match?.[targetFieldId]\n      return value != null ? displayValue(value) : null\n    })\n    .filter((value): value is string => value != null)\n  return resolved.length ? resolved.join(', ') : null\n}\n\nfunction substituteValue(\n  value: unknown,\n  context: SubstituteContext,\n): unknown {\n  const { record } = context\n  if (typeof value === 'string') {\n    return value.replace(\n      ITEM_TOKEN_PATTERN,\n      (token, field: string, hop?: string) => {\n        if (hop) {\n          const resolved = resolveReferenceHop(context, field, hop)\n          return resolved != null ? resolved : token\n        }\n        return record[field] != null ? displayValue(record[field]) : token\n      },\n    )\n  }\n  if (Array.isArray(value)) {\n    return value.map((entry) => substituteValue(entry, context))\n  }\n  if (value && typeof value === 'object') {\n    const next: Record<string, unknown> = {}\n    for (const [key, entry] of Object.entries(value)) {\n      next[key] = substituteValue(entry, context)\n    }\n    return next\n  }\n  return value\n}\n\n/**\n * The key a node repeats over, trimmed, or `''` when it repeats over nothing.\n *\n * The one predicate every repeat question is asked through: the expansion, the\n * datasets-read gate below, the reusable-component graft that moves a\n * placement's repeat onto the element it becomes, and the besigner's preview\n * and badge. Two copies of it are how a `.trim()` on one side and not the\n * other becomes an empty list on a customer's page.\n */\nexport const repeatKey = (node: unknown): string => {\n  const key = (node as { props?: { repeatDataset?: unknown } })?.props\n    ?.repeatDataset\n  return typeof key === 'string' ? key.trim() : ''\n}\n\n/**\n * Makes an element that holds children repeat ITSELF, once per record, instead\n * of what is inside it (AGL-3111): a card whose contents are the design, rather\n * than a list whose contents are the item.\n *\n * Persisted in screen, layout and component documents — never rename. `'true'`\n * counts too, because a switch round-tripped through a text-shaped store comes\n * back as the string.\n */\nexport const REPEAT_SELF_PROP = 'repeatSelf'\n\n/**\n * Every prop that directs a repeat. They are instructions to the composition,\n * never attributes of the element: the expansion consumes them from every node\n * it expands and every copy it makes, so a published element never carries\n * one. Persisted — never rename.\n */\nexport const REPEAT_DIRECTIVE_PROPS: readonly string[] = [\n  'repeatDataset',\n  'repeatLimit',\n  'repeatFilter',\n  'repeatSort',\n  REPEAT_SELF_PROP,\n]\n\n/**\n * What a repeating node copies once per record (AGL-3111).\n *\n * - `children` — what is inside it. The node stays one element around the\n *   copies: the list, grid or gallery they fill. This is how a Stack has\n *   always repeated (AGL-103), and a stored Stack names neither scope.\n * - `self` — the node itself, with everything inside it. What a leaf and a\n *   component instance repeat, and what any element carrying\n *   {@link REPEAT_SELF_PROP} repeats.\n */\nexport type RepeatScope = 'self' | 'children'\n\n/**\n * Which scope a repeating node has, read off the node alone so the published\n * page's composition and the besigner decide it identically.\n *\n * {@link REPEAT_SELF_PROP} decides it whenever the node carries one, which is\n * every repeat the Attributes panel writes. Without one the node's own shape\n * decides, and it decides CONSERVATIVELY: anything that holds a child list —\n * a Stack, empty or not — keeps repeating its children, and only a node with\n * no child list at all repeats itself. A stored repeat predates the prop, so\n * this branch is the one that has to render it unchanged, and an author who\n * named a dataset before filling the container in would otherwise come back to\n * a hundred empty copies of it.\n *\n * A component instance never reaches that branch: the graft stamps the prop on\n * the element it becomes, whose children are the component's own.\n */\nexport function repeatScope(node: unknown): RepeatScope {\n  const { props, nodes } = (node ?? {}) as {\n    props?: Record<string, unknown>\n    nodes?: unknown\n  }\n  // `'true'`/`'false'` too: a switch round-tripped through a text-shaped\n  // store comes back as the string it was written as.\n  const self = props?.[REPEAT_SELF_PROP]\n  if (self === true || self === 'true') return 'self'\n  if (self === false || self === 'false') return 'children'\n  return Array.isArray(nodes) ? 'children' : 'self'\n}\n\n/**\n * One record's values put into `{{item.field}}` tokens, anywhere in a props\n * map — the substitution {@link expandRepeatables} makes on every copy it\n * builds, for a caller that already knows which record it is rendering.\n *\n * The besigner's canvas is that caller (AGL-3111): the element an author\n * edits IS the first copy, so it draws with the first record's values while\n * the node it saves keeps the tokens. Exported rather than reimplemented\n * because a canvas that resolved a token differently from the page would be\n * showing the author a page that does not exist.\n */\nexport function substituteRecordTokens<T>(\n  props: T,\n  context: {\n    record: Record<string, unknown>\n    /** Model of the repeated rows; reference hops need field configs. */\n    model?: import('./dataset-models').DatasetModel\n    /** Rows by key, for a one-hop reference (AGL-180). */\n    datasetsByKey?: Record<string, RepeatableDataset | undefined>\n  },\n): T {\n  return substituteValue(props, context) as T\n}\n\n/** The node minus its repeat directives, or the node itself when it has none. */\nexport function withoutRepeatDirective<N>(node: N): N {\n  const props = (node as { props?: Record<string, unknown> })?.props\n  if (!props || !REPEAT_DIRECTIVE_PROPS.some((key) => key in props)) {\n    return node\n  }\n  const kept = { ...props }\n  for (const key of REPEAT_DIRECTIVE_PROPS) delete kept[key]\n  return { ...node, props: kept }\n}\n\n/**\n * The records a repeating node renders, in order (AGL-181): its filter and sort\n * evaluated over the rows, then its limit, never past\n * {@link REPEAT_MAX_RECORDS}. An unparseable filter or sort fails open.\n *\n * Shared by the expansion and the besigner's canvas preview and badge, so the\n * canvas can never show a copy or a count the published page does not.\n */\nexport function repeatedRecords(\n  node: unknown,\n  dataset: RepeatableDataset | undefined,\n): Array<Record<string, unknown>> {\n  const props = ((node as { props?: unknown })?.props ?? {}) as Record<\n    string,\n    unknown\n  >\n  const where = parseDatasetFilter(String(props['repeatFilter'] ?? ''))\n  const orderBy = parseDatasetSort(String(props['repeatSort'] ?? ''))\n  const limit = Number(props['repeatLimit'])\n  return applyDatasetQuery(dataset?.model, dataset?.records ?? [], {\n    ...(where ? { where: [where] } : {}),\n    ...(orderBy ? { orderBy } : {}),\n  }).slice(\n    0,\n    Number.isFinite(limit) && limit > 0\n      ? Math.min(limit, REPEAT_MAX_RECORDS)\n      : REPEAT_MAX_RECORDS,\n  )\n}\n\n/**\n * Does this tree contain anything {@link expandRepeatables} would expand?\n *\n * The datasets read is the largest on the render path — up to two pages of\n * {@link REPEAT_MAX_RECORDS} records for every dataset a page repeats over —\n * and a page that repeats over nothing should pay none of it (AGL-1440).\n *\n * Any gate on that read has to ask EXACTLY the question the expansion asks,\n * which is why this and {@link repeatDatasetKeys} share the one predicate\n * `expandRepeatables` looks keys up with, {@link repeatKey}. A gate that is\n * even slightly stricter than the expansion is not a saving: it is a published\n * page that quietly renders one template row where the author put a list.\n */\nexport function hasRepeatableNodes(\n  nodes: Record<NodeId, unknown> | null | undefined,\n): boolean {\n  if (!nodes) return false\n  return Object.values(nodes).some((node) => repeatKey(node) !== '')\n}\n\n/**\n * Every dataset key this tree repeats over — a dataset id or a display name,\n * exactly as {@link expandRepeatables} looks it up — sorted and without\n * repeats.\n *\n * What the tenant compose reads, so a page loads the datasets it renders and\n * not every dataset its site may see. Built on the same predicate as\n * {@link hasRepeatableNodes} for the reason given there.\n */\nexport function repeatDatasetKeys(\n  nodes: Record<NodeId, unknown> | null | undefined,\n): string[] {\n  const keys = new Set<string>()\n  for (const node of Object.values(nodes ?? {})) {\n    const key = repeatKey(node)\n    if (key) keys.add(key)\n  }\n  return [...keys].sort()\n}\n\n/**\n * Repeats (AGL-103, AGL-3111): any node carrying `props.repeatDataset` (a\n * dataset id or display name) renders once per record of that dataset, with\n * `{{item.field}}` tokens in the copied string props replaced by the record's\n * values (unknown fields keep the literal token, like variable bindings).\n *\n * What is copied is the node's {@link repeatScope}:\n *\n * - `children` — its children are the item template. The node stays, and its\n *   child list becomes the copies, record by record. Its own props are not the\n *   template, so no token in them is substituted.\n * - `self` — the node and everything inside it are the template. The copies\n *   take the node's place in its parent's child list, and every prop in the\n *   subtree is substituted, the node's own included.\n *\n * - Copy ids are namespaced `rep__{repeatId}__{index}__…` — the repeat's own\n *   id, then the template node's — so repeats never collide, including inside\n *   grafted reusable components. A self-scoped node's first copy is\n *   `rep__{id}__0__{id}`. Run this AFTER `composeReusableComponentNodes` and\n *   BEFORE binding resolution.\n * - Rows are the node's {@link repeatedRecords}.\n * - The repeat directives ({@link REPEAT_DIRECTIVE_PROPS}) are consumed: every\n *   node this expands, and every copy it makes, comes out without them.\n * - Repeats do not nest. A repeat inside another repeat's template is copied\n *   with its directives consumed, so it renders once in each copy.\n * - An unknown dataset, no matching records, an empty template, or a\n *   self-scoped node its parent does not list (the document root, say) leave\n *   the node rendering once, as written (fail-open: a deleted dataset must\n *   never take a published screen down).\n * - Inputs are never mutated; templates stay in the map unreferenced.\n */\nexport function expandRepeatables<N extends AglynNodeSchema = AglynNodeSchema>(\n  nodes: Record<NodeId, N>,\n  datasetsByKey: Record<string, RepeatableDataset | undefined> | undefined,\n): Record<NodeId, N> {\n  if (!datasetsByKey) return nodes\n  const repeatIds = Object.entries(nodes).filter(\n    ([, node]) => repeatKey(node) !== '',\n  )\n  if (!repeatIds.length) return nodes\n\n  const next: Record<NodeId, N> = { ...nodes }\n  for (const [repeatId, repeated] of repeatIds) {\n    const dataset = datasetsByKey[repeatKey(repeated)]\n    const records = repeatedRecords(repeated, dataset)\n    const self = repeatScope(repeated) === 'self'\n    // The copies' parent: the node itself, or — for a self-scoped node — the\n    // parent whose child list the copies take its place in, read from `next`\n    // so two self-scoped siblings both land in the list the other has left.\n    const parentId = (self ? repeated.parentId : repeatId) as NodeId\n    const siblings = next[parentId]?.nodes\n    const slot = Array.isArray(siblings)\n      ? (siblings as NodeId[]).indexOf(repeatId)\n      : -1\n    const templateIds = self\n      ? [repeatId]\n      : Array.isArray(repeated.nodes)\n        ? (repeated.nodes as NodeId[])\n        : []\n    next[repeatId] = withoutRepeatDirective(next[repeatId])\n    if (!records.length || !templateIds.length || (self && slot < 0)) continue\n\n    const copyIds: NodeId[] = []\n    records.forEach((record, index) => {\n      const prefix = `${REPEAT_NODE_ID_PREFIX}${repeatId}__${index}__`\n      const prefixId = (id: NodeId) => `${prefix}${id}`\n      const cloneSubtree = (id: NodeId, clonedParentId: NodeId) => {\n        const node = nodes[id]\n        if (!node) return\n        const clonedChildren = Array.isArray(node.nodes)\n          ? (node.nodes as NodeId[])\n          : undefined\n        next[prefixId(id)] = withoutRepeatDirective({\n          ...node,\n          $id: prefixId(id),\n          parentId: clonedParentId,\n          props: substituteValue(node.props ?? {}, {\n            record,\n            model: dataset?.model,\n            datasetsByKey,\n          }) as any,\n          ...(clonedChildren && {\n            nodes: clonedChildren.map((childId) => prefixId(childId)),\n          }),\n        })\n        clonedChildren?.forEach((childId) =>\n          cloneSubtree(childId, prefixId(id)),\n        )\n      }\n      for (const templateId of templateIds) {\n        cloneSubtree(templateId, parentId)\n        copyIds.push(prefixId(templateId))\n      }\n    })\n    if (self) {\n      const listed = [...(next[parentId].nodes as NodeId[])]\n      listed.splice(slot, 1, ...copyIds)\n      next[parentId] = { ...next[parentId], nodes: listed }\n    } else {\n      next[repeatId] = { ...next[repeatId], nodes: copyIds }\n    }\n  }\n  return next\n}\n\nexport default expandRepeatables\n"],"names":["applyDatasetQuery","parseDatasetFilter","parseDatasetSort","REPEAT_NODE_ID_PREFIX","ITEM_TOKEN_PATTERN","REPEAT_MAX_RECORDS","displayValue","value","Array","isArray","join","String","resolveReferenceHop","context","fieldId","targetFieldId","field","model","fields","type","reference","datasetId","target","datasetsByKey","keys","record","ids","resolved","map","id","match","records","find","row","filter","length","substituteValue","replace","token","hop","entry","next","key","Object","entries","repeatKey","node","props","repeatDataset","trim","REPEAT_SELF_PROP","REPEAT_DIRECTIVE_PROPS","repeatScope","nodes","self","substituteRecordTokens","withoutRepeatDirective","some","kept","repeatedRecords","dataset","where","orderBy","limit","Number","slice","isFinite","Math","min","hasRepeatableNodes","values","repeatDatasetKeys","Set","add","sort","expandRepeatables","repeatIds","repeatId","repeated","parentId","siblings","slot","indexOf","templateIds","copyIds","forEach","index","prefix","prefixId","cloneSubtree","clonedParentId","clonedChildren","undefined","$id","childId","templateId","push","listed","splice"],"mappings":"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"}

package/src/lib/app-utils/foreign-script.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @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.
+ */
+/**
+ * Code running in our pages that no deployment of ours served (AGL-2786).
+ *
+ * Two collectors have to tell our code from somebody else's running inside
+ * the same document, and both answer it from a URL: the CSP collector off a
+ * violation's source or blocked URI, the error beacon off every frame of a
+ * stack. They read ONE list, because a second copy fails silently — a scheme
+ * learned in one place goes on paging from the other.
+ *
+ * Pure and framework-free: the beacon ships in every page's client bundle and
+ * the ingestion routes run the same rule on the server, so nothing here may
+ * reach `window` or a Node builtin.
+ */
+/**
+ * Schemes no deployment of ours serves a script from.
+ *
+ * - Extension content scripts, the overwhelming majority of CSP reports on
+ *   any real deployment: `chrome-extension:`, `moz-extension:`,
+ *   `safari-extension:`, `safari-web-extension:`, `edge-extension:`.
+ * - `webkit-masked-url:` — Safari's redaction of the same thing. Opaque, so
+ *   it can never be actioned, and it arrives in volume.
+ * - `chrome:`, `resource:`, `asset:` — the browser's and the embedding app's
+ *   own internals.
+ * - `iabjs:` — the scheme Meta's Facebook/Instagram Android in-app browser
+ *   evaluates its own scripts under. Measured 2026-09-10 in `client-errors`:
+ *   `Error invoking postMessage: Java object is gone`, every frame under
+ *   `iabjs://navigation_performance_logger_android`, thrown by the webview's
+ *   native bridge as the page unloaded.
+ *
+ * Schemes, not vendors or function names: a new webview adds a scheme at
+ * most, and nothing on this list can ever be ours.
+ */
+export declare const FOREIGN_SCRIPT_SCHEMES: readonly string[];
+/** Is this URL under a scheme no deployment of ours serves? */
+export declare function isForeignScriptUrl(value: string): boolean;
+/**
+ * Every URL a stack frame points at, whichever engine produced the stack.
+ *
+ * One pattern covers both formats because the frame's URL is always followed
+ * by `:line:col`: V8 writes `at fn (URL:1:2)` and `at URL:1:2`, WebKit and
+ * Firefox write `fn@URL:1:2` and `@URL:1:2`. Matching on the suffix rather
+ * than on the prefix means neither engine needs its own branch, and a format
+ * this code has never seen degrades to "no frames parsed" rather than to a
+ * wrong answer.
+ *
+ * ANY scheme, not a list of web ones. A frame the pattern cannot read does
+ * not parse, and a stack made only of such frames reads as "no frames" —
+ * which every caller treats as no evidence and keeps. That is how an
+ * `iabjs://` stack came to be reported as ours.
+ */
+export declare function stackFrameUrls(stack: string): string[];
+/**
+ * Was every frame of this stack evaluated under a foreign scheme?
+ *
+ * ⚑ `every`, never `some`: injected code calling into ours is OUR bug the
+ * moment one of our frames is on the stack, so a single first-party frame —
+ * a served chunk, a CDN asset, the document itself — keeps the report.
+ *
+ * No frames parsed is not evidence of anything, so it is false.
+ *
+ * The document is NOT foreign here. The beacon also drops a stack whose
+ * frames are the document (see `isInjectedThirdPartyFrame`), but only for an
+ * uncaught error, in the browser, against the page's own URL. Anything
+ * reading a stack without that context must not guess.
+ */
+export declare function isForeignScriptStack(stack: string): boolean;