@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/node-interactions.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @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 { HostAction } from './actions';
+/**
+ * Interactions stored on the element that carries them.
+ *
+ * An interaction is what an ELEMENT does — clicked, hovered, scrolled into
+ * view. A host action is what the SITE does — an order was placed, a form was
+ * submitted. Both compile to the same runtime shape, and until now both were
+ * stored the same way too, as rows in `hosts/{hostId}/actions` bound to an
+ * element by selector. That made an interaction a site-wide object that
+ * merely happened to point at one element, with all four consequences an
+ * author would be surprised by: it did not publish or roll back with its
+ * screen, it did not travel with a copied component or a packaged template,
+ * deleting the element orphaned it, and it cluttered the site's automation
+ * list with a nav menu's hover timing.
+ *
+ * Here the node owns them, so all four answer themselves — the node is the
+ * thing that versions, travels, and is deleted.
+ *
+ * ## The selector is not stored
+ *
+ * `trigger.selector` is derived from the node's id at compose time, never
+ * persisted. A stored selector is a second name for the element that can
+ * disagree with the first: a duplicate, a re-key, or a paste into another
+ * document would carry a selector still naming the ORIGINAL element, and the
+ * interaction would silently drive someone else's button. Deriving it means
+ * the copy binds to the copy, which is the whole reason for moving the
+ * storage.
+ */
+export interface NodeInteraction extends Omit<HostAction, 'trigger'> {
+    /** Stable within its node, so an edit updates rather than appends. */
+    id: string;
+    trigger: Omit<HostAction['trigger'], 'selector'>;
+}
+/** Cap per element. Ten triggers on one button is a bug, not a design. */
+export declare const NODE_MAX_INTERACTIONS = 10;
+/** The selector the renderer stamps for a node, and the runtime targets. */
+export declare function nodeInteractionSelector(nodeId: string): string;
+/** The node a derived selector names, or undefined for anything else. */
+export declare function nodeIdFromInteractionSelector(selector: unknown): string | undefined;
+/**
+ * The prefix that makes a collected id say where it lives.
+ *
+ * Every surface that can toggle, edit or delete an interaction is handed an
+ * id and nothing else, and there are now two places one can be stored. A
+ * self-describing id is what lets those surfaces route without a second
+ * lookup — and, more to the point, without GUESSING, which during the
+ * migration would mean writing a node interaction into the actions
+ * collection or vice versa.
+ */
+export declare const NODE_INTERACTION_ID_PREFIX = "node:";
+/** The node and interaction a collected id names, or null for a host action. */
+export declare function parseNodeInteractionId(id: unknown): {
+    nodeId: string;
+    interactionId: string;
+} | null;
+/** The collected id for one interaction on one node. */
+export declare function nodeInteractionId(nodeId: string, interactionId: string): string;
+/** Minimal node shape this module reads; the canvas node satisfies it. */
+export interface InteractionNode {
+    $id?: string;
+    interactions?: NodeInteraction[] | null;
+    /** Denormalized children. Ids are the normalized form and carry nothing. */
+    nodes?: unknown;
+}
+export declare function walkInteractionNodes(root: InteractionNode | null | undefined): Generator<InteractionNode>;
+/** One interaction resolved into the runtime's own shape. */
+export interface CollectedNodeInteraction {
+    /**
+     * Namespaced with the node id, so two elements carrying the same preset —
+     * two Dropdown Panels inserted from the same source — cannot collide, and
+     * so a runtime keyed on this id (the once-per-visitor and cooldown caps
+     * are) treats them as the separate things they are.
+     */
+    id: string;
+    action: HostAction;
+}
+export declare function collectNodeInteractions(nodes: Iterable<InteractionNode | null | undefined>): CollectedNodeInteraction[];
+/**
+ * The interactions on one node with one entry added or replaced.
+ *
+ * Returns a new array; never mutates the one passed in, which is a MobX
+ * observable on the canvas and a plain array everywhere else.
+ */
+export declare function upsertNodeInteraction(interactions: readonly NodeInteraction[] | undefined, interaction: NodeInteraction): NodeInteraction[];
+/** The interactions on one node with one removed. */
+export declare function removeNodeInteraction(interactions: readonly NodeInteraction[] | undefined, id: string): NodeInteraction[];

package/src/lib/app-utils/node-interactions.js

@@ -0,0 +1,192 @@
+/**
+ * @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";
+/** Cap per element. Ten triggers on one button is a bug, not a design. */ export const NODE_MAX_INTERACTIONS = 10;
+/** The selector the renderer stamps for a node, and the runtime targets. */ export function nodeInteractionSelector(nodeId) {
+    return `[data-aglyn="leaf:${nodeId}"]`;
+}
+/** The node a derived selector names, or undefined for anything else. */ export function nodeIdFromInteractionSelector(selector) {
+    const match = /^\[data-aglyn="leaf:(.+)"\]$/.exec(String(selector != null ? selector : ''));
+    return (match == null ? void 0 : match[1]) || undefined;
+}
+/**
+ * The prefix that makes a collected id say where it lives.
+ *
+ * Every surface that can toggle, edit or delete an interaction is handed an
+ * id and nothing else, and there are now two places one can be stored. A
+ * self-describing id is what lets those surfaces route without a second
+ * lookup — and, more to the point, without GUESSING, which during the
+ * migration would mean writing a node interaction into the actions
+ * collection or vice versa.
+ */ export const NODE_INTERACTION_ID_PREFIX = 'node:';
+/** The node and interaction a collected id names, or null for a host action. */ export function parseNodeInteractionId(id) {
+    const value = String(id != null ? id : '');
+    if (!value.startsWith(NODE_INTERACTION_ID_PREFIX)) return null;
+    const rest = value.slice(NODE_INTERACTION_ID_PREFIX.length);
+    // The node id comes first and cannot contain a colon; the interaction id
+    // takes the remainder, so a colon inside one survives the round trip.
+    const separator = rest.indexOf(':');
+    if (separator <= 0 || separator === rest.length - 1) return null;
+    return {
+        nodeId: rest.slice(0, separator),
+        interactionId: rest.slice(separator + 1)
+    };
+}
+/** The collected id for one interaction on one node. */ export function nodeInteractionId(nodeId, interactionId) {
+    return `${NODE_INTERACTION_ID_PREFIX}${nodeId}:${interactionId}`;
+}
+/**
+ * Every node in a DENORMALIZED tree, depth-first, parents before children.
+ *
+ * Composition is what makes this the right input: a layout's chrome and a
+ * reusable component's internals are grafted in by then, and their node ids
+ * are the graft ids the renderer actually stamps. Collecting from the raw
+ * screen document instead would derive a selector for an id that is never on
+ * the page — which is the same bug as a stored selector, arrived at from the
+ * other direction.
+ *
+ * A normalized tree (children as id strings) yields only the node it was
+ * given; there is nothing to follow, and guessing at a lookup table this
+ * module does not have would be worse than answering honestly.
+ */ /** A single node rather than a map of them: it names itself. */ function isInteractionNodeLike(value) {
+    return !!value && typeof value === 'object' && typeof value.$id === 'string';
+}
+export function* walkInteractionNodes(root) {
+    /*
+   * A NORMALIZED map is the shape the tenant actually composes.
+   *
+   * `composeScreenNodes` returns `{ [id]: node }` with children as id
+   * STRINGS, and the enricher handed that straight here. The old code took
+   * the map itself for a node: it carries no `$id` and no `interactions`, its
+   * `nodes` property does not exist, so the walk yielded one useless object
+   * and stopped. Every node interaction on every published page was dropped —
+   * silently, because an empty automation list is what a page with none looks
+   * like.
+   *
+   * A map is recognisable without guessing: no `$id`, no `nodes` array, and
+   * every value an object carrying its own `$id`. Yielding its values is
+   * exact rather than a lookup this module would have to invent — the map is
+   * already flat, so there is nothing to follow.
+   */ if (root && typeof root === 'object' && !isInteractionNodeLike(root)) {
+        const values = Object.values(root);
+        if (values.length && values.every((v)=>isInteractionNodeLike(v))) {
+            for (const node of values)yield node;
+            return;
+        }
+    }
+    if (!root || typeof root !== 'object') return;
+    yield root;
+    const children = root.nodes;
+    if (!Array.isArray(children)) return;
+    for (const child of children){
+        if (child && typeof child === 'object') {
+            yield* walkInteractionNodes(child);
+        }
+    }
+}
+/**
+ * Every interaction in a composed tree, in the runtime's shape.
+ *
+ * Order follows the nodes, which is document order — a page with two
+ * elements listening for the same event fires them in the order they appear,
+ * which is the only ordering an author can predict.
+ *
+ * Disabled interactions are kept, not dropped. The compiler downstream is the
+ * one place that decides what runs (it also applies the plan trims), and two
+ * places deciding is how a step gets dropped for a reason nobody can find.
+ */ /**
+ * Step selectors, re-pointed at the ids the graft actually stamped.
+ *
+ * A trigger needs no help: the node IS the selector, derived above from the
+ * composed id. A STEP is different — it names another element, and it was
+ * written when the component was authored, so it holds that component's own
+ * id. Grafting an instance re-stamps every id with the instance's prefix, so
+ * `[data-aglyn="leaf:panel"]` names nothing on a page that renders
+ * `leaf:cmp__inst__panel`, and a mega menu opens nothing.
+ *
+ * Rewritten only when the bare id is absent AND exactly the prefixed sibling
+ * is present: an interaction that legitimately targets a page-level element
+ * from inside a component keeps working, and an unresolvable selector is left
+ * exactly as written rather than pointed somewhere plausible.
+ */ function regraftStepSelectors(steps, nodeId, present) {
+    const boundary = nodeId.lastIndexOf('__');
+    if (boundary < 0) return steps;
+    const prefix = nodeId.slice(0, boundary + 2);
+    if (!prefix) return steps;
+    return (steps != null ? steps : []).map((step)=>{
+        const targetId = nodeIdFromInteractionSelector(step == null ? void 0 : step.selector);
+        if (!targetId || present.has(targetId)) return step;
+        const grafted = `${prefix}${targetId}`;
+        if (!present.has(grafted)) return step;
+        return _extends({}, step, {
+            selector: nodeInteractionSelector(grafted)
+        });
+    });
+}
+export function collectNodeInteractions(nodes) {
+    const collected = [];
+    const all = [
+        ...nodes
+    ];
+    const present = new Set(all.map((node)=>node == null ? void 0 : node.$id).filter((id)=>!!id));
+    for (const node of all){
+        const nodeId = node == null ? void 0 : node.$id;
+        if (!nodeId || !Array.isArray(node == null ? void 0 : node.interactions)) continue;
+        let index = 0;
+        for (const interaction of node.interactions){
+            var _interaction_trigger;
+            if (index >= NODE_MAX_INTERACTIONS) break;
+            if (!(interaction == null ? void 0 : (_interaction_trigger = interaction.trigger) == null ? void 0 : _interaction_trigger.event)) continue;
+            index += 1;
+            collected.push({
+                id: nodeInteractionId(nodeId, interaction.id || String(index)),
+                action: _extends({}, interaction, Array.isArray(interaction.steps) ? {
+                    steps: regraftStepSelectors(interaction.steps, nodeId, present)
+                } : {}, {
+                    trigger: _extends({}, interaction.trigger, {
+                        // Derived here and nowhere else — see the note above on why it
+                        // is not stored.
+                        selector: nodeInteractionSelector(nodeId)
+                    })
+                })
+            });
+        }
+    }
+    return collected;
+}
+/**
+ * The interactions on one node with one entry added or replaced.
+ *
+ * Returns a new array; never mutates the one passed in, which is a MobX
+ * observable on the canvas and a plain array everywhere else.
+ */ export function upsertNodeInteraction(interactions, interaction) {
+    const current = interactions != null ? interactions : [];
+    const existing = current.findIndex((entry)=>entry.id === interaction.id);
+    if (existing < 0) return [
+        ...current,
+        interaction
+    ].slice(0, NODE_MAX_INTERACTIONS);
+    const next = [
+        ...current
+    ];
+    next[existing] = interaction;
+    return next;
+}
+/** The interactions on one node with one removed. */ export function removeNodeInteraction(interactions, id) {
+    return (interactions != null ? interactions : []).filter((entry)=>entry.id !== id);
+}
+
+//# sourceMappingURL=node-interactions.js.map

package/src/lib/app-utils/node-interactions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/node-interactions.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 { HostAction } from './actions'\n\n/**\n * Interactions stored on the element that carries them.\n *\n * An interaction is what an ELEMENT does — clicked, hovered, scrolled into\n * view. A host action is what the SITE does — an order was placed, a form was\n * submitted. Both compile to the same runtime shape, and until now both were\n * stored the same way too, as rows in `hosts/{hostId}/actions` bound to an\n * element by selector. That made an interaction a site-wide object that\n * merely happened to point at one element, with all four consequences an\n * author would be surprised by: it did not publish or roll back with its\n * screen, it did not travel with a copied component or a packaged template,\n * deleting the element orphaned it, and it cluttered the site's automation\n * list with a nav menu's hover timing.\n *\n * Here the node owns them, so all four answer themselves — the node is the\n * thing that versions, travels, and is deleted.\n *\n * ## The selector is not stored\n *\n * `trigger.selector` is derived from the node's id at compose time, never\n * persisted. A stored selector is a second name for the element that can\n * disagree with the first: a duplicate, a re-key, or a paste into another\n * document would carry a selector still naming the ORIGINAL element, and the\n * interaction would silently drive someone else's button. Deriving it means\n * the copy binds to the copy, which is the whole reason for moving the\n * storage.\n */\nexport interface NodeInteraction extends Omit<HostAction, 'trigger'> {\n  /** Stable within its node, so an edit updates rather than appends. */\n  id: string\n  trigger: Omit<HostAction['trigger'], 'selector'>\n}\n\n/** Cap per element. Ten triggers on one button is a bug, not a design. */\nexport const NODE_MAX_INTERACTIONS = 10\n\n/** The selector the renderer stamps for a node, and the runtime targets. */\nexport function nodeInteractionSelector(nodeId: string): string {\n  return `[data-aglyn=\"leaf:${nodeId}\"]`\n}\n\n/** The node a derived selector names, or undefined for anything else. */\nexport function nodeIdFromInteractionSelector(\n  selector: unknown,\n): string | undefined {\n  const match = /^\\[data-aglyn=\"leaf:(.+)\"\\]$/.exec(String(selector ?? ''))\n  return match?.[1] || undefined\n}\n\n/**\n * The prefix that makes a collected id say where it lives.\n *\n * Every surface that can toggle, edit or delete an interaction is handed an\n * id and nothing else, and there are now two places one can be stored. A\n * self-describing id is what lets those surfaces route without a second\n * lookup — and, more to the point, without GUESSING, which during the\n * migration would mean writing a node interaction into the actions\n * collection or vice versa.\n */\nexport const NODE_INTERACTION_ID_PREFIX = 'node:'\n\n/** The node and interaction a collected id names, or null for a host action. */\nexport function parseNodeInteractionId(\n  id: unknown,\n): { nodeId: string; interactionId: string } | null {\n  const value = String(id ?? '')\n  if (!value.startsWith(NODE_INTERACTION_ID_PREFIX)) return null\n  const rest = value.slice(NODE_INTERACTION_ID_PREFIX.length)\n  // The node id comes first and cannot contain a colon; the interaction id\n  // takes the remainder, so a colon inside one survives the round trip.\n  const separator = rest.indexOf(':')\n  if (separator <= 0 || separator === rest.length - 1) return null\n  return {\n    nodeId: rest.slice(0, separator),\n    interactionId: rest.slice(separator + 1),\n  }\n}\n\n/** The collected id for one interaction on one node. */\nexport function nodeInteractionId(\n  nodeId: string,\n  interactionId: string,\n): string {\n  return `${NODE_INTERACTION_ID_PREFIX}${nodeId}:${interactionId}`\n}\n\n/** Minimal node shape this module reads; the canvas node satisfies it. */\nexport interface InteractionNode {\n  $id?: string\n  interactions?: NodeInteraction[] | null\n  /** Denormalized children. Ids are the normalized form and carry nothing. */\n  nodes?: unknown\n}\n\n/**\n * Every node in a DENORMALIZED tree, depth-first, parents before children.\n *\n * Composition is what makes this the right input: a layout's chrome and a\n * reusable component's internals are grafted in by then, and their node ids\n * are the graft ids the renderer actually stamps. Collecting from the raw\n * screen document instead would derive a selector for an id that is never on\n * the page — which is the same bug as a stored selector, arrived at from the\n * other direction.\n *\n * A normalized tree (children as id strings) yields only the node it was\n * given; there is nothing to follow, and guessing at a lookup table this\n * module does not have would be worse than answering honestly.\n */\n/** A single node rather than a map of them: it names itself. */\nfunction isInteractionNodeLike(value: unknown): boolean {\n  return (\n    !!value &&\n    typeof value === 'object' &&\n    typeof (value as { $id?: unknown }).$id === 'string'\n  )\n}\n\nexport function* walkInteractionNodes(\n  root: InteractionNode | null | undefined,\n): Generator<InteractionNode> {\n  /*\n   * A NORMALIZED map is the shape the tenant actually composes.\n   *\n   * `composeScreenNodes` returns `{ [id]: node }` with children as id\n   * STRINGS, and the enricher handed that straight here. The old code took\n   * the map itself for a node: it carries no `$id` and no `interactions`, its\n   * `nodes` property does not exist, so the walk yielded one useless object\n   * and stopped. Every node interaction on every published page was dropped —\n   * silently, because an empty automation list is what a page with none looks\n   * like.\n   *\n   * A map is recognisable without guessing: no `$id`, no `nodes` array, and\n   * every value an object carrying its own `$id`. Yielding its values is\n   * exact rather than a lookup this module would have to invent — the map is\n   * already flat, so there is nothing to follow.\n   */\n  if (root && typeof root === 'object' && !isInteractionNodeLike(root)) {\n    const values = Object.values(root as Record<string, unknown>)\n    if (values.length && values.every((v) => isInteractionNodeLike(v))) {\n      for (const node of values) yield node as InteractionNode\n      return\n    }\n  }\n  if (!root || typeof root !== 'object') return\n  yield root\n  const children = (root as { nodes?: unknown }).nodes\n  if (!Array.isArray(children)) return\n  for (const child of children) {\n    if (child && typeof child === 'object') {\n      yield* walkInteractionNodes(child as InteractionNode)\n    }\n  }\n}\n\n/** One interaction resolved into the runtime's own shape. */\nexport interface CollectedNodeInteraction {\n  /**\n   * Namespaced with the node id, so two elements carrying the same preset —\n   * two Dropdown Panels inserted from the same source — cannot collide, and\n   * so a runtime keyed on this id (the once-per-visitor and cooldown caps\n   * are) treats them as the separate things they are.\n   */\n  id: string\n  action: HostAction\n}\n\n/**\n * Every interaction in a composed tree, in the runtime's shape.\n *\n * Order follows the nodes, which is document order — a page with two\n * elements listening for the same event fires them in the order they appear,\n * which is the only ordering an author can predict.\n *\n * Disabled interactions are kept, not dropped. The compiler downstream is the\n * one place that decides what runs (it also applies the plan trims), and two\n * places deciding is how a step gets dropped for a reason nobody can find.\n */\n/**\n * Step selectors, re-pointed at the ids the graft actually stamped.\n *\n * A trigger needs no help: the node IS the selector, derived above from the\n * composed id. A STEP is different — it names another element, and it was\n * written when the component was authored, so it holds that component's own\n * id. Grafting an instance re-stamps every id with the instance's prefix, so\n * `[data-aglyn=\"leaf:panel\"]` names nothing on a page that renders\n * `leaf:cmp__inst__panel`, and a mega menu opens nothing.\n *\n * Rewritten only when the bare id is absent AND exactly the prefixed sibling\n * is present: an interaction that legitimately targets a page-level element\n * from inside a component keeps working, and an unresolvable selector is left\n * exactly as written rather than pointed somewhere plausible.\n */\nfunction regraftStepSelectors(\n  steps: HostAction['steps'],\n  nodeId: string,\n  present: ReadonlySet<string>,\n): HostAction['steps'] {\n  const boundary = nodeId.lastIndexOf('__')\n  if (boundary < 0) return steps\n  const prefix = nodeId.slice(0, boundary + 2)\n  if (!prefix) return steps\n  return (steps ?? []).map((step) => {\n    const targetId = nodeIdFromInteractionSelector(\n      (step as { selector?: unknown })?.selector,\n    )\n    if (!targetId || present.has(targetId)) return step\n    const grafted = `${prefix}${targetId}`\n    if (!present.has(grafted)) return step\n    return { ...step, selector: nodeInteractionSelector(grafted) }\n  }) as HostAction['steps']\n}\n\nexport function collectNodeInteractions(\n  nodes: Iterable<InteractionNode | null | undefined>,\n): CollectedNodeInteraction[] {\n  const collected: CollectedNodeInteraction[] = []\n  const all = [...nodes]\n  const present = new Set(\n    all.map((node) => node?.$id).filter((id): id is string => !!id),\n  )\n  for (const node of all) {\n    const nodeId = node?.$id\n    if (!nodeId || !Array.isArray(node?.interactions)) continue\n    let index = 0\n    for (const interaction of node.interactions) {\n      if (index >= NODE_MAX_INTERACTIONS) break\n      if (!interaction?.trigger?.event) continue\n      index += 1\n      collected.push({\n        id: nodeInteractionId(nodeId, interaction.id || String(index)),\n        action: {\n          ...interaction,\n          ...(Array.isArray((interaction as { steps?: unknown }).steps)\n            ? {\n                steps: regraftStepSelectors(\n                  (interaction as unknown as HostAction).steps,\n                  nodeId,\n                  present,\n                ),\n              }\n            : {}),\n          trigger: {\n            ...interaction.trigger,\n            // Derived here and nowhere else — see the note above on why it\n            // is not stored.\n            selector: nodeInteractionSelector(nodeId),\n          },\n        } as HostAction,\n      })\n    }\n  }\n  return collected\n}\n\n/**\n * The interactions on one node with one entry added or replaced.\n *\n * Returns a new array; never mutates the one passed in, which is a MobX\n * observable on the canvas and a plain array everywhere else.\n */\nexport function upsertNodeInteraction(\n  interactions: readonly NodeInteraction[] | undefined,\n  interaction: NodeInteraction,\n): NodeInteraction[] {\n  const current = interactions ?? []\n  const existing = current.findIndex((entry) => entry.id === interaction.id)\n  if (existing < 0) return [...current, interaction].slice(0, NODE_MAX_INTERACTIONS)\n  const next = [...current]\n  next[existing] = interaction\n  return next\n}\n\n/** The interactions on one node with one removed. */\nexport function removeNodeInteraction(\n  interactions: readonly NodeInteraction[] | undefined,\n  id: string,\n): NodeInteraction[] {\n  return (interactions ?? []).filter((entry) => entry.id !== id)\n}\n"],"names":["NODE_MAX_INTERACTIONS","nodeInteractionSelector","nodeId","nodeIdFromInteractionSelector","selector","match","exec","String","undefined","NODE_INTERACTION_ID_PREFIX","parseNodeInteractionId","id","value","startsWith","rest","slice","length","separator","indexOf","interactionId","nodeInteractionId","isInteractionNodeLike","$id","walkInteractionNodes","root","values","Object","every","v","node","children","nodes","Array","isArray","child","regraftStepSelectors","steps","present","boundary","lastIndexOf","prefix","map","step","targetId","has","grafted","collectNodeInteractions","collected","all","Set","filter","interactions","index","interaction","trigger","event","push","action","upsertNodeInteraction","current","existing","findIndex","entry","next","removeNodeInteraction"],"mappings":"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"}

package/src/lib/app-utils/node-url-policy.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @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.
+ */
+/**
+ * An image address: `https:`, an inline image, a site path or a fragment.
+ *
+ * `https:` only, unlike {@link SAFE_HREF_PATTERN} (AGL-1701). An `http:` href is
+ * a link a reader chooses to follow and their browser will warn about; an
+ * `http:` image is fetched automatically, and on the authenticated console —
+ * or on any tenant page served over TLS — it is mixed content, which every
+ * current browser blocks outright. The permissive form bought nothing: the
+ * image did not render either way, it just failed at the viewer.
+ */
+export declare const SAFE_SRC_PATTERN: RegExp;
+/** The props that carry an address. */
+export type NodeUrlProp = 'href' | 'src';
+/** Every prop {@link isSafeNodeUrl} judges, in one place for a walker. */
+export declare const NODE_URL_PROPS: readonly NodeUrlProp[];
+/**
+ * Whether `value` is an address this prop may carry.
+ *
+ * `siteReferences` also admits what the site resolves on its own — a screen
+ * or collection link (`screen:…`, `collection:…`) for `href`, a media-library
+ * reference (`media:…`) for `src`. The linking elements route the first
+ * through the routing map and the image element turns the second into a CDN
+ * path, so neither reaches the DOM as written. A page on its own site renders
+ * with them; a tree published to another workspace may not carry them, since
+ * they name the publisher's screens and files.
+ *
+ * Judged on the value with its surrounding whitespace removed, which is how
+ * the linking elements read a link too.
+ */
+export declare function isSafeNodeUrl(prop: NodeUrlProp, value: unknown, options?: {
+    siteReferences?: boolean;
+}): boolean;
+/**
+ * Whether an address names a scheme, read the way a browser reads one: with
+ * the controls and spaces it strips from a URL removed first, so
+ * `java\tscript:` names `javascript`. An address with none is relative.
+ */
+export declare function hasUrlScheme(value: string): boolean;

package/src/lib/app-utils/node-url-policy.js

@@ -0,0 +1,72 @@
+/**
+ * @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.
+ */ /**
+ * The addresses an element's `href` and `src` may hold (AGL-784, AGL-2933).
+ *
+ * `Leaf` spreads a node's props onto its component, and a component passes
+ * what it does not consume to its root DOM element, so an `href` or `src`
+ * that survives composition is a browser navigating or fetching. One rule
+ * says which addresses may get that far, read by the two places a value is
+ * handed to a page it was not written on: publishing a tree to another
+ * workspace, and substituting a property's value into the tree that binds it.
+ */ import { parseMediaRef } from "./media-ref.js";
+import { parseScreenLinkValue, SAFE_HREF_PATTERN } from "./screen-link-value.js";
+/**
+ * An image address: `https:`, an inline image, a site path or a fragment.
+ *
+ * `https:` only, unlike {@link SAFE_HREF_PATTERN} (AGL-1701). An `http:` href is
+ * a link a reader chooses to follow and their browser will warn about; an
+ * `http:` image is fetched automatically, and on the authenticated console —
+ * or on any tenant page served over TLS — it is mixed content, which every
+ * current browser blocks outright. The permissive form bought nothing: the
+ * image did not render either way, it just failed at the viewer.
+ */ export const SAFE_SRC_PATTERN = /^(https:\/\/|data:image\/|\/|#)/i;
+/** Every prop {@link isSafeNodeUrl} judges, in one place for a walker. */ export const NODE_URL_PROPS = [
+    'href',
+    'src'
+];
+/**
+ * Whether `value` is an address this prop may carry.
+ *
+ * `siteReferences` also admits what the site resolves on its own — a screen
+ * or collection link (`screen:…`, `collection:…`) for `href`, a media-library
+ * reference (`media:…`) for `src`. The linking elements route the first
+ * through the routing map and the image element turns the second into a CDN
+ * path, so neither reaches the DOM as written. A page on its own site renders
+ * with them; a tree published to another workspace may not carry them, since
+ * they name the publisher's screens and files.
+ *
+ * Judged on the value with its surrounding whitespace removed, which is how
+ * the linking elements read a link too.
+ */ export function isSafeNodeUrl(prop, value, options) {
+    if (typeof value !== 'string') return false;
+    const address = value.trim();
+    const pattern = prop === 'href' ? SAFE_HREF_PATTERN : SAFE_SRC_PATTERN;
+    if (pattern.test(address)) return true;
+    if (!(options == null ? void 0 : options.siteReferences)) return false;
+    return prop === 'href' ? parseScreenLinkValue(address) !== undefined : parseMediaRef(address) !== null;
+}
+/**
+ * Whether an address names a scheme, read the way a browser reads one: with
+ * the controls and spaces it strips from a URL removed first, so
+ * `java\tscript:` names `javascript`. An address with none is relative.
+ */ export function hasUrlScheme(value) {
+    // eslint-disable-next-line no-control-regex
+    const compact = value.replace(/[\u0000-\u0020\u007f]/g, '');
+    return /^[a-z][a-z0-9+.-]*:/i.test(compact);
+}
+
+//# sourceMappingURL=node-url-policy.js.map

package/src/lib/app-utils/node-url-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/node-url-policy.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\n/**\n * The addresses an element's `href` and `src` may hold (AGL-784, AGL-2933).\n *\n * `Leaf` spreads a node's props onto its component, and a component passes\n * what it does not consume to its root DOM element, so an `href` or `src`\n * that survives composition is a browser navigating or fetching. One rule\n * says which addresses may get that far, read by the two places a value is\n * handed to a page it was not written on: publishing a tree to another\n * workspace, and substituting a property's value into the tree that binds it.\n */\n\nimport { parseMediaRef } from './media-ref'\nimport { parseScreenLinkValue, SAFE_HREF_PATTERN } from './screen-link-value'\n\n/**\n * An image address: `https:`, an inline image, a site path or a fragment.\n *\n * `https:` only, unlike {@link SAFE_HREF_PATTERN} (AGL-1701). An `http:` href is\n * a link a reader chooses to follow and their browser will warn about; an\n * `http:` image is fetched automatically, and on the authenticated console —\n * or on any tenant page served over TLS — it is mixed content, which every\n * current browser blocks outright. The permissive form bought nothing: the\n * image did not render either way, it just failed at the viewer.\n */\nexport const SAFE_SRC_PATTERN = /^(https:\\/\\/|data:image\\/|\\/|#)/i\n\n/** The props that carry an address. */\nexport type NodeUrlProp = 'href' | 'src'\n\n/** Every prop {@link isSafeNodeUrl} judges, in one place for a walker. */\nexport const NODE_URL_PROPS: readonly NodeUrlProp[] = ['href', 'src']\n\n/**\n * Whether `value` is an address this prop may carry.\n *\n * `siteReferences` also admits what the site resolves on its own — a screen\n * or collection link (`screen:…`, `collection:…`) for `href`, a media-library\n * reference (`media:…`) for `src`. The linking elements route the first\n * through the routing map and the image element turns the second into a CDN\n * path, so neither reaches the DOM as written. A page on its own site renders\n * with them; a tree published to another workspace may not carry them, since\n * they name the publisher's screens and files.\n *\n * Judged on the value with its surrounding whitespace removed, which is how\n * the linking elements read a link too.\n */\nexport function isSafeNodeUrl(\n  prop: NodeUrlProp,\n  value: unknown,\n  options?: { siteReferences?: boolean },\n): boolean {\n  if (typeof value !== 'string') return false\n  const address = value.trim()\n  const pattern = prop === 'href' ? SAFE_HREF_PATTERN : SAFE_SRC_PATTERN\n  if (pattern.test(address)) return true\n  if (!options?.siteReferences) return false\n  return prop === 'href'\n    ? parseScreenLinkValue(address) !== undefined\n    : parseMediaRef(address) !== null\n}\n\n/**\n * Whether an address names a scheme, read the way a browser reads one: with\n * the controls and spaces it strips from a URL removed first, so\n * `java\\tscript:` names `javascript`. An address with none is relative.\n */\nexport function hasUrlScheme(value: string): boolean {\n  // eslint-disable-next-line no-control-regex\n  const compact = value.replace(/[\\u0000-\\u0020\\u007f]/g, '')\n  return /^[a-z][a-z0-9+.-]*:/i.test(compact)\n}\n"],"names":["parseMediaRef","parseScreenLinkValue","SAFE_HREF_PATTERN","SAFE_SRC_PATTERN","NODE_URL_PROPS","isSafeNodeUrl","prop","value","options","address","trim","pattern","test","siteReferences","undefined","hasUrlScheme","compact","replace"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;CASC,GAED,SAASA,aAAa,QAAQ,iBAAa;AAC3C,SAASC,oBAAoB,EAAEC,iBAAiB,QAAQ,yBAAqB;AAE7E;;;;;;;;;CASC,GACD,OAAO,MAAMC,mBAAmB,mCAAkC;AAKlE,wEAAwE,GACxE,OAAO,MAAMC,iBAAyC;IAAC;IAAQ;CAAM,CAAA;AAErE;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,cACdC,IAAiB,EACjBC,KAAc,EACdC,OAAsC;IAEtC,IAAI,OAAOD,UAAU,UAAU,OAAO;IACtC,MAAME,UAAUF,MAAMG,IAAI;IAC1B,MAAMC,UAAUL,SAAS,SAASJ,oBAAoBC;IACtD,IAAIQ,QAAQC,IAAI,CAACH,UAAU,OAAO;IAClC,IAAI,EAACD,2BAAAA,QAASK,cAAc,GAAE,OAAO;IACrC,OAAOP,SAAS,SACZL,qBAAqBQ,aAAaK,YAClCd,cAAcS,aAAa;AACjC;AAEA;;;;CAIC,GACD,OAAO,SAASM,aAAaR,KAAa;IACxC,4CAA4C;IAC5C,MAAMS,UAAUT,MAAMU,OAAO,CAAC,0BAA0B;IACxD,OAAO,uBAAuBL,IAAI,CAACI;AACrC"}

package/src/lib/app-utils/notifications.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 { ITimestamp } from '@aglyn/shared-util-timestamp';
+/**
+ * In-app notifications (AGL-259): per-user docs at
+ * `users/{uid}/notifications/{id}`, written by the Admin SDK (emitters in
+ * the API routes + the `notifyAdmins` automation step) and read/marked by
+ * their owner. Types follow the common SaaS taxonomy so the console can
+ * icon/group them without a registry.
+ */
+export type AglynNotificationType = 'billing.invoice' | 'billing.paymentFailed' | 'billing.subscriptionCanceled' | 'billing.usage' | 'team.invite' | 'team.roleChanged' | 'team.hostAccessGranted' | 'content.formSubmission' | 'content.booking' | 'content.order' | 'content.lowStock' | 'content.taskAssigned' | 'content.taskReminder' | 'content.contactAssigned' | 'content.leadAssigned' | 'content.crmDailyDigest' | 'content.insightsDigest' | 'marketplace.review' | 'support.ticketOpened' | 'support.ticketReply' | 'system.announcement' | 'system.pluginVerifierRegression' | 'system.signInMethodRemoved' | 'system.scopeDrift' | 'system.ssoDomainUnverified' | 'system.formSubmissionsPaused' | 'system.visitorRecordsPaused' | 'system.abuseReportUrgent' | 'system.dmcaCounterNotice' | 'system.bandwidthCeilingTripped' | 'system.bandwidthCapEngaged' | 'system.billingWebhookHalfApplied' | 'system.disputeUnattributed';
+export interface AglynNotification {
+    $id?: string;
+    type: AglynNotificationType;
+    title: string;
+    body?: string;
+    /** Console path the notification opens (e.g. a host inbox). */
+    link?: string;
+    orgId?: string;
+    hostId?: string;
+    createdAt?: ITimestamp;
+    /** Set by the owner when read; unread while absent. */
+    readAt?: ITimestamp | null;
+}
+export declare const NOTIFICATION_TYPE_LABELS: Record<AglynNotificationType, string>;
+/** Preference buckets (AGL-267): the prefix before the dot. */
+export type NotificationCategory = 'billing' | 'team' | 'content' | 'marketplace' | 'support' | 'system';
+export declare const NOTIFICATION_CATEGORY_LABELS: Record<NotificationCategory, string>;
+export declare function notificationCategory(type: AglynNotificationType | string): NotificationCategory;
+/**
+ * Per-user mute map stored at `users/{uid}.notificationPrefs`
+ * (`{ [category]: false }` mutes); absent categories stay on.
+ */
+export declare function notificationMuted(prefs: Record<string, boolean> | null | undefined, type: AglynNotificationType | string): boolean;
+/**
+ * The field on `users/{uid}` that holds a person's digest switches
+ * (AGL-2619): `{ crmDaily: false }` turns the daily CRM digest off, and an
+ * absent key leaves it on. Its own map rather than a key in
+ * `notificationPrefs`, because that map is keyed by CATEGORY and read by
+ * {@link notificationMuted} — a digest is a schedule a person keeps or
+ * drops, not a bucket of types, and one switch governs both the console
+ * notification and the email it travels with.
+ */
+export declare const DIGEST_PREFS_FIELD = "digestPrefs";
+export declare function crmDailyDigestEnabled(prefs: Record<string, boolean> | null | undefined): boolean;
+/**
+ * The field on `users/{uid}` naming the workspaces whose weekly insights a
+ * person asked for (AGL-2915): `{ [orgId]: true }`. OPT-IN, unlike the CRM
+ * digest — an absent key is off — because a weekly insight is generated, and a
+ * generation spends the workspace's credits. The person turns it on beside the
+ * answers themselves, where the plan, the release and their permission have
+ * already been checked, and off again there or in Notifications; the weekly
+ * sweep checks all three again before it spends anything.
+ */
+export declare const INSIGHT_DIGESTS_FIELD = "insightDigests";
+/** Whether a person asked for a workspace's weekly insights. */
+export declare function insightDigestSubscribed(value: Record<string, boolean> | null | undefined, orgId: string): boolean;

package/src/lib/app-utils/notifications.js

@@ -0,0 +1,101 @@
+/**
+ * @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.
+ */ export const NOTIFICATION_TYPE_LABELS = {
+    'billing.invoice': 'Invoice available',
+    'billing.paymentFailed': 'Payment failed',
+    'billing.subscriptionCanceled': 'Subscription canceled',
+    'billing.usage': 'Usage threshold',
+    'team.invite': 'Team invite',
+    'team.roleChanged': 'Role changed',
+    'team.hostAccessGranted': 'Site access granted',
+    'content.formSubmission': 'Form submission',
+    'content.booking': 'New booking',
+    'content.order': 'New order',
+    'content.lowStock': 'Low stock',
+    'content.taskAssigned': 'Task assigned to you',
+    'content.taskReminder': 'Task reminder',
+    'content.contactAssigned': 'Contact assigned to you',
+    'content.leadAssigned': 'Lead assigned to you',
+    'content.crmDailyDigest': 'Daily CRM digest',
+    'content.insightsDigest': 'Weekly insights',
+    'marketplace.review': 'Listing review',
+    'support.ticketOpened': 'New support ticket',
+    'support.ticketReply': 'Support ticket reply',
+    'system.announcement': 'Announcement',
+    'system.pluginVerifierRegression': 'Plugin verifier regression',
+    'system.signInMethodRemoved': 'Sign-in method removed',
+    'system.scopeDrift': 'Resources missing a sharing scope',
+    'system.ssoDomainUnverified': 'SSO domain no longer proves ownership',
+    'system.formSubmissionsPaused': 'Form submissions paused',
+    'system.visitorRecordsPaused': 'Sign-ups or leads paused',
+    'system.abuseReportUrgent': 'Urgent abuse report',
+    'system.dmcaCounterNotice': 'DMCA counter-notice',
+    'system.bandwidthCeilingTripped': 'Bandwidth ceiling reached',
+    'system.bandwidthCapEngaged': 'Monthly traffic limit reached',
+    'system.billingWebhookHalfApplied': 'Billing webhook half applied',
+    'system.disputeUnattributed': 'Card dispute with no owner'
+};
+export const NOTIFICATION_CATEGORY_LABELS = {
+    billing: 'Billing',
+    team: 'Team & access',
+    content: 'Forms & bookings',
+    marketplace: 'Marketplace',
+    support: 'Support',
+    system: 'Product & system'
+};
+export function notificationCategory(type) {
+    const prefix = String(type).split('.')[0];
+    return [
+        'billing',
+        'team',
+        'content',
+        'marketplace',
+        'support',
+        'system'
+    ].includes(prefix) ? prefix : 'system';
+}
+/**
+ * Per-user mute map stored at `users/{uid}.notificationPrefs`
+ * (`{ [category]: false }` mutes); absent categories stay on.
+ */ export function notificationMuted(prefs, type) {
+    return (prefs == null ? void 0 : prefs[notificationCategory(type)]) === false;
+}
+/**
+ * The field on `users/{uid}` that holds a person's digest switches
+ * (AGL-2619): `{ crmDaily: false }` turns the daily CRM digest off, and an
+ * absent key leaves it on. Its own map rather than a key in
+ * `notificationPrefs`, because that map is keyed by CATEGORY and read by
+ * {@link notificationMuted} — a digest is a schedule a person keeps or
+ * drops, not a bucket of types, and one switch governs both the console
+ * notification and the email it travels with.
+ */ export const DIGEST_PREFS_FIELD = 'digestPrefs';
+export function crmDailyDigestEnabled(prefs) {
+    return (prefs == null ? void 0 : prefs['crmDaily']) !== false;
+}
+/**
+ * The field on `users/{uid}` naming the workspaces whose weekly insights a
+ * person asked for (AGL-2915): `{ [orgId]: true }`. OPT-IN, unlike the CRM
+ * digest — an absent key is off — because a weekly insight is generated, and a
+ * generation spends the workspace's credits. The person turns it on beside the
+ * answers themselves, where the plan, the release and their permission have
+ * already been checked, and off again there or in Notifications; the weekly
+ * sweep checks all three again before it spends anything.
+ */ export const INSIGHT_DIGESTS_FIELD = 'insightDigests';
+/** Whether a person asked for a workspace's weekly insights. */ export function insightDigestSubscribed(value, orgId) {
+    return Boolean(orgId) && (value == null ? void 0 : value[orgId]) === true;
+}
+
+//# sourceMappingURL=notifications.js.map