@aglyn/aglyn 1.0.0-beta.143

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

@@ -0,0 +1,233 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @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.
+ */ // Token grammar shared with the picker/besigner (AGL-185/194): id-form
+// tokens only — legacy name resolution retired after the production
+// content migration ran clean.
+import { FUNCTION_TOKEN_PATTERN, VARIABLE_ID_TOKEN_PATTERN } from "./binding-tokens.js";
+import { evaluateExpression, evaluateHostFunction, functionReferencedNames } from "./functions.js";
+export const HOST_VARIABLE_TYPE_LABELS = {
+    date: 'Date',
+    time: 'Time',
+    text: 'Plain text',
+    number: 'Number',
+    boolean: 'True/false (boolean)',
+    dictionary: 'Dictionary (key: value)',
+    collection: 'Collection list (values)'
+};
+export const VARIABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]{0,39}$/;
+/** Human-readable rendering of a variable's value for text interpolation. */ export function formatVariableValue(variable) {
+    var _variable_value;
+    const raw = (_variable_value = variable.value) != null ? _variable_value : '';
+    switch(variable.type){
+        case 'boolean':
+            return raw === 'true' ? 'true' : 'false';
+        case 'number':
+            {
+                const parsed = Number(raw);
+                return Number.isFinite(parsed) ? String(parsed) : '';
+            }
+        case 'date':
+            {
+                const parsed = new Date(raw);
+                return Number.isNaN(parsed.getTime()) ? raw : parsed.toLocaleDateString(undefined, {
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                    timeZone: 'UTC'
+                });
+            }
+        case 'dictionary':
+        case 'collection':
+            {
+                // Stored as JSON; render collections comma-joined and dictionaries
+                // as `key: value` pairs so a bare {{name}} stays readable.
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (Array.isArray(parsed)) return parsed.map(String).join(', ');
+                    if (parsed && typeof parsed === 'object') {
+                        return Object.entries(parsed).map(([key, value])=>`${key}: ${value}`).join(', ');
+                    }
+                } catch (unused) {
+                // fall through to the raw string
+                }
+                return raw;
+            }
+        case 'time':
+        case 'text':
+        default:
+            return raw;
+    }
+}
+/**
+ * Variable values as an expression scope (numbers stay numeric). Keyed by
+ * each doc's NAME regardless of how the lookup map is keyed (AGL-194:
+ * maps are id-keyed now, but expressions reference variables by name).
+ */ function variableScope(variables) {
+    const scope = {};
+    for (const variable of Object.values(variables)){
+        if (!(variable == null ? void 0 : variable.name)) continue;
+        if (variable.type === 'number') {
+            var _variable_value;
+            scope[variable.name] = Number((_variable_value = variable.value) != null ? _variable_value : 0);
+        } else if (variable.type === 'boolean') {
+            scope[variable.name] = variable.value === 'true';
+        } else {
+            var _variable_value1;
+            scope[variable.name] = (_variable_value1 = variable.value) != null ? _variable_value1 : '';
+        }
+    }
+    return scope;
+}
+/**
+ * Replaces binding tokens with values (AGL-91/93/185/194): id forms
+ * `{{var:id}}` / `{{fn:id(args)}}` resolve through id-keyed lookup maps.
+ * Function args are expressions over literals and variable NAMES (the
+ * scope keys by each doc's name). Unknown function refs keep the literal
+ * token; unknown variable ids render empty; bare `{{name}}` strings are
+ * plain text since the legacy fallback retired.
+ */ export function resolveBindings(text, variables, functions = {}) {
+    const withVariableIds = text.replace(VARIABLE_ID_TOKEN_PATTERN, (_token, id)=>{
+        const variable = variables[String(id)];
+        // Unknown ids render EMPTY, not literal (AGL-186): a raw doc id is
+        // meaningless to visitors, unlike a readable legacy {{name}} token.
+        return variable ? formatVariableValue(variable) : '';
+    });
+    const withFunctions = withVariableIds.replace(FUNCTION_TOKEN_PATTERN, (token, rawName, rawArgs)=>{
+        const definition = functions[String(rawName).trim()];
+        if (!definition) return token;
+        try {
+            var _definition_parameters;
+            const scope = variableScope(variables);
+            const argValues = String(rawArgs).split(',').map((argument)=>argument.trim()).filter((argument)=>argument.length > 0).map((argument)=>evaluateExpression(argument, scope));
+            const args = {};
+            (_definition_parameters = definition.parameters) == null ? void 0 : _definition_parameters.forEach((parameter, index)=>{
+                args[parameter.name] = argValues[index];
+            });
+            // The site's variables are the function's outer scope (AGL-3202),
+            // so `{{fn:id(25)}}` can price 25 sites without every rate being
+            // passed in by position. Arguments still win over a variable of the
+            // same name, as every parameter does.
+            const result = evaluateHostFunction(definition, args, {
+                globals: scope
+            });
+            return result.ok ? String(result.value) : token;
+        } catch (unused) {
+            return token;
+        }
+    });
+    // Legacy {{name}} resolution retired (AGL-194): the production content
+    // migration ran clean, so bare-name tokens are plain text now. Typing
+    // them in the editor still works — save-time normalization converts
+    // known names to id tokens before they persist.
+    return withFunctions;
+}
+/** Fast pre-check so binding-free content skips the walk entirely. */ export function hasBindings(text) {
+    return /\{\{/.test(text);
+}
+/**
+ * Applies `resolveBindings` to every string prop across a normalized nodes
+ * map (mutating a shallow copy). String props only — objects/arrays (sx,
+ * option lists) pass through untouched; unsafe values in hrefs remain
+ * covered by the render-time SAFE_HREF/sanitizer checks.
+ */ /** Component id of the interactive function widget (plugins-mui). */ export const FUNCTION_WIDGET_COMPONENT_ID = 'functionWidget';
+/**
+ * Component id of the Calculator container (plugins-mui, AGL-3202): the
+ * other element that runs a function in the visitor's browser, and so the
+ * other one compose hands a definition to.
+ */ export const FUNCTION_SCOPE_COMPONENT_ID = 'functionScope';
+const FUNCTION_RUNNING_COMPONENT_IDS = new Set([
+    FUNCTION_WIDGET_COMPONENT_ID,
+    FUNCTION_SCOPE_COMPONENT_ID
+]);
+/**
+ * The site variables ONE function reads, by name (AGL-3202).
+ *
+ * A widget runs in the visitor's browser, so whatever it may read has to be
+ * on the page. Handing it the whole variable list would publish every value
+ * a site holds to every page that places a calculator; this hands over the
+ * names the function's own expressions use and nothing else. A name the
+ * function declares itself is not a variable read — its parameter or local
+ * shadows the variable — so it is not shipped either.
+ */ export function functionGlobals(definition, variables) {
+    const scope = variableScope(variables);
+    const globals = {};
+    for (const name of functionReferencedNames(definition)){
+        if (Object.prototype.hasOwnProperty.call(scope, name)) {
+            globals[name] = scope[name];
+        }
+    }
+    return globals;
+}
+/**
+ * Injects each function widget's definition into its props at compose time
+ * (AGL-93): the client runs the shared evaluator locally, so the published
+ * page carries the definition instead of calling home. Unknown names leave
+ * the node untouched (the widget renders its editor placeholder).
+ *
+ * With `variables`, the site variables that function reads ride along as
+ * `globals` (AGL-3202) — see {@link functionGlobals} for why it is only
+ * those. The key is omitted when the function reads none, so a page built
+ * before this existed serializes exactly as it did.
+ */ export function attachFunctionDefinitions(nodes, functions, variables = {}) {
+    if (!Object.keys(functions).length) return nodes;
+    const next = {};
+    for (const [id, node] of Object.entries(nodes)){
+        var _node_props;
+        const name = FUNCTION_RUNNING_COMPONENT_IDS.has(node == null ? void 0 : node.componentId) ? node == null ? void 0 : (_node_props = node.props) == null ? void 0 : _node_props.functionName : undefined;
+        const definition = name ? functions[String(name).trim()] : undefined;
+        if (!definition) {
+            next[id] = node;
+            continue;
+        }
+        const globals = functionGlobals(definition, variables);
+        next[id] = _extends({}, node, {
+            props: _extends({}, node.props, {
+                definition
+            }, Object.keys(globals).length ? {
+                globals
+            } : {})
+        });
+    }
+    return next;
+}
+export function resolveNodesBindings(nodes, variables, functions = {}) {
+    if (!Object.keys(variables).length && !Object.keys(functions).length) {
+        return nodes;
+    }
+    const next = {};
+    for (const [id, node] of Object.entries(nodes)){
+        const props = node == null ? void 0 : node.props;
+        if (!props) {
+            next[id] = node;
+            continue;
+        }
+        let changed = false;
+        const nextProps = _extends({}, props);
+        for (const [key, value] of Object.entries(props)){
+            if (typeof value === 'string' && hasBindings(value)) {
+                nextProps[key] = resolveBindings(value, variables, functions);
+                changed = true;
+            }
+        }
+        next[id] = changed ? _extends({}, node, {
+            props: nextProps
+        }) : node;
+    }
+    return next;
+}
+
+//# sourceMappingURL=variables.js.map

package/src/lib/app-utils/variables.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/variables.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// Token grammar shared with the picker/besigner (AGL-185/194): id-form\n// tokens only — legacy name resolution retired after the production\n// content migration ran clean.\nimport {\n  FUNCTION_TOKEN_PATTERN,\n  VARIABLE_ID_TOKEN_PATTERN,\n} from './binding-tokens'\nimport {\n  evaluateExpression,\n  evaluateHostFunction,\n  functionReferencedNames,\n  type HostFunction,\n} from './functions'\n\n/**\n * Host variables (Component Builder, AGL-91): typed values authored in the\n * console and bound into component text props with `{{name}}` — and, since\n * AGL-93, function results with `{{fn:name(args)}}`. Pure data module\n * shared by the console editor UI and the tenant compose pipeline.\n */\n\n/** Types from the mockup's Edit Variable dialog (\"Function\" lands with AGL-92). */\nexport type HostVariableType =\n  | 'date'\n  | 'time'\n  | 'text'\n  | 'number'\n  | 'boolean'\n  | 'dictionary'\n  | 'collection'\n\nexport const HOST_VARIABLE_TYPE_LABELS: Record<HostVariableType, string> = {\n  date: 'Date',\n  time: 'Time',\n  text: 'Plain text',\n  number: 'Number',\n  boolean: 'True/false (boolean)',\n  dictionary: 'Dictionary (key: value)',\n  collection: 'Collection list (values)',\n}\n\n/** `hosts/{hostId}/variables/{id}` doc. */\nexport interface HostVariable {\n  /** Binding identifier — `{{name}}`. */\n  name: string\n  type: HostVariableType\n  /** Persisted as a string; formatted per type at resolve time. */\n  value?: string\n  /**\n   * Workflow (by name) whose result becomes this variable's value at\n   * compose time (AGL-129); `value` acts as the fallback when the\n   * workflow is missing or fails.\n   */\n  workflowName?: string\n  /** Computed source by workflow doc id (AGL-261); wins over the name. */\n  workflowId?: string\n}\n\nexport const VARIABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]{0,39}$/\n\n/** Human-readable rendering of a variable's value for text interpolation. */\nexport function formatVariableValue(variable: HostVariable): string {\n  const raw = variable.value ?? ''\n  switch (variable.type) {\n    case 'boolean':\n      return raw === 'true' ? 'true' : 'false'\n    case 'number': {\n      const parsed = Number(raw)\n      return Number.isFinite(parsed) ? String(parsed) : ''\n    }\n    case 'date': {\n      const parsed = new Date(raw)\n      return Number.isNaN(parsed.getTime())\n        ? raw\n        : parsed.toLocaleDateString(undefined, {\n            year: 'numeric',\n            month: 'long',\n            day: 'numeric',\n            timeZone: 'UTC',\n          })\n    }\n    case 'dictionary':\n    case 'collection': {\n      // Stored as JSON; render collections comma-joined and dictionaries\n      // as `key: value` pairs so a bare {{name}} stays readable.\n      try {\n        const parsed = JSON.parse(raw)\n        if (Array.isArray(parsed)) return parsed.map(String).join(', ')\n        if (parsed && typeof parsed === 'object') {\n          return Object.entries(parsed)\n            .map(([key, value]) => `${key}: ${value}`)\n            .join(', ')\n        }\n      } catch {\n        // fall through to the raw string\n      }\n      return raw\n    }\n    case 'time':\n    case 'text':\n    default:\n      return raw\n  }\n}\n\n/** A function definition lookup keyed by function name (AGL-93). */\nexport type HostFunctionLookup = Record<string, HostFunction>\n\n/**\n * Variable values as an expression scope (numbers stay numeric). Keyed by\n * each doc's NAME regardless of how the lookup map is keyed (AGL-194:\n * maps are id-keyed now, but expressions reference variables by name).\n */\nfunction variableScope(\n  variables: Record<string, HostVariable>,\n): Record<string, number | string | boolean> {\n  const scope: Record<string, number | string | boolean> = {}\n  for (const variable of Object.values(variables)) {\n    if (!variable?.name) continue\n    if (variable.type === 'number') {\n      scope[variable.name] = Number(variable.value ?? 0)\n    } else if (variable.type === 'boolean') {\n      scope[variable.name] = variable.value === 'true'\n    } else {\n      scope[variable.name] = variable.value ?? ''\n    }\n  }\n  return scope\n}\n\n/**\n * Replaces binding tokens with values (AGL-91/93/185/194): id forms\n * `{{var:id}}` / `{{fn:id(args)}}` resolve through id-keyed lookup maps.\n * Function args are expressions over literals and variable NAMES (the\n * scope keys by each doc's name). Unknown function refs keep the literal\n * token; unknown variable ids render empty; bare `{{name}}` strings are\n * plain text since the legacy fallback retired.\n */\nexport function resolveBindings(\n  text: string,\n  variables: Record<string, HostVariable>,\n  functions: HostFunctionLookup = {},\n): string {\n  const withVariableIds = text.replace(\n    VARIABLE_ID_TOKEN_PATTERN,\n    (_token, id) => {\n      const variable = variables[String(id)]\n      // Unknown ids render EMPTY, not literal (AGL-186): a raw doc id is\n      // meaningless to visitors, unlike a readable legacy {{name}} token.\n      return variable ? formatVariableValue(variable) : ''\n    },\n  )\n  const withFunctions = withVariableIds.replace(\n    FUNCTION_TOKEN_PATTERN,\n    (token, rawName, rawArgs) => {\n      const definition = functions[String(rawName).trim()]\n      if (!definition) return token\n      try {\n        const scope = variableScope(variables)\n        const argValues = String(rawArgs)\n          .split(',')\n          .map((argument) => argument.trim())\n          .filter((argument) => argument.length > 0)\n          .map((argument) => evaluateExpression(argument, scope))\n        const args: Record<string, unknown> = {}\n        definition.parameters?.forEach((parameter, index) => {\n          args[parameter.name] = argValues[index]\n        })\n        // The site's variables are the function's outer scope (AGL-3202),\n        // so `{{fn:id(25)}}` can price 25 sites without every rate being\n        // passed in by position. Arguments still win over a variable of the\n        // same name, as every parameter does.\n        const result = evaluateHostFunction(definition, args, {\n          globals: scope,\n        })\n        return result.ok ? String(result.value) : token\n      } catch {\n        return token\n      }\n    },\n  )\n  // Legacy {{name}} resolution retired (AGL-194): the production content\n  // migration ran clean, so bare-name tokens are plain text now. Typing\n  // them in the editor still works — save-time normalization converts\n  // known names to id tokens before they persist.\n  return withFunctions\n}\n\n/** Fast pre-check so binding-free content skips the walk entirely. */\nexport function hasBindings(text: string): boolean {\n  return /\\{\\{/.test(text)\n}\n\n/**\n * Applies `resolveBindings` to every string prop across a normalized nodes\n * map (mutating a shallow copy). String props only — objects/arrays (sx,\n * option lists) pass through untouched; unsafe values in hrefs remain\n * covered by the render-time SAFE_HREF/sanitizer checks.\n */\n/** Component id of the interactive function widget (plugins-mui). */\nexport const FUNCTION_WIDGET_COMPONENT_ID = 'functionWidget'\n\n/**\n * Component id of the Calculator container (plugins-mui, AGL-3202): the\n * other element that runs a function in the visitor's browser, and so the\n * other one compose hands a definition to.\n */\nexport const FUNCTION_SCOPE_COMPONENT_ID = 'functionScope'\n\nconst FUNCTION_RUNNING_COMPONENT_IDS: ReadonlySet<string> = new Set([\n  FUNCTION_WIDGET_COMPONENT_ID,\n  FUNCTION_SCOPE_COMPONENT_ID,\n])\n\n/**\n * The site variables ONE function reads, by name (AGL-3202).\n *\n * A widget runs in the visitor's browser, so whatever it may read has to be\n * on the page. Handing it the whole variable list would publish every value\n * a site holds to every page that places a calculator; this hands over the\n * names the function's own expressions use and nothing else. A name the\n * function declares itself is not a variable read — its parameter or local\n * shadows the variable — so it is not shipped either.\n */\nexport function functionGlobals(\n  definition: HostFunction,\n  variables: Record<string, HostVariable>,\n): Record<string, number | string | boolean> {\n  const scope = variableScope(variables)\n  const globals: Record<string, number | string | boolean> = {}\n  for (const name of functionReferencedNames(definition)) {\n    if (Object.prototype.hasOwnProperty.call(scope, name)) {\n      globals[name] = scope[name]\n    }\n  }\n  return globals\n}\n\n/**\n * Injects each function widget's definition into its props at compose time\n * (AGL-93): the client runs the shared evaluator locally, so the published\n * page carries the definition instead of calling home. Unknown names leave\n * the node untouched (the widget renders its editor placeholder).\n *\n * With `variables`, the site variables that function reads ride along as\n * `globals` (AGL-3202) — see {@link functionGlobals} for why it is only\n * those. The key is omitted when the function reads none, so a page built\n * before this existed serializes exactly as it did.\n */\nexport function attachFunctionDefinitions<T extends Record<string, any>>(\n  nodes: T,\n  functions: HostFunctionLookup,\n  variables: Record<string, HostVariable> = {},\n): T {\n  if (!Object.keys(functions).length) return nodes\n  const next: Record<string, any> = {}\n  for (const [id, node] of Object.entries(nodes)) {\n    const name = FUNCTION_RUNNING_COMPONENT_IDS.has(node?.componentId)\n      ? node?.props?.functionName\n      : undefined\n    const definition = name ? functions[String(name).trim()] : undefined\n    if (!definition) {\n      next[id] = node\n      continue\n    }\n    const globals = functionGlobals(definition, variables)\n    next[id] = {\n      ...node,\n      props: {\n        ...node.props,\n        definition,\n        ...(Object.keys(globals).length ? { globals } : {}),\n      },\n    }\n  }\n  return next as T\n}\n\nexport function resolveNodesBindings<T extends Record<string, any>>(\n  nodes: T,\n  variables: Record<string, HostVariable>,\n  functions: HostFunctionLookup = {},\n): T {\n  if (!Object.keys(variables).length && !Object.keys(functions).length) {\n    return nodes\n  }\n  const next: Record<string, any> = {}\n  for (const [id, node] of Object.entries(nodes)) {\n    const props = node?.props\n    if (!props) {\n      next[id] = node\n      continue\n    }\n    let changed = false\n    const nextProps: Record<string, unknown> = { ...props }\n    for (const [key, value] of Object.entries(props)) {\n      if (typeof value === 'string' && hasBindings(value)) {\n        nextProps[key] = resolveBindings(value, variables, functions)\n        changed = true\n      }\n    }\n    next[id] = changed ? { ...node, props: nextProps } : node\n  }\n  return next as T\n}\n"],"names":["FUNCTION_TOKEN_PATTERN","VARIABLE_ID_TOKEN_PATTERN","evaluateExpression","evaluateHostFunction","functionReferencedNames","HOST_VARIABLE_TYPE_LABELS","date","time","text","number","boolean","dictionary","collection","VARIABLE_NAME_PATTERN","formatVariableValue","variable","raw","value","type","parsed","Number","isFinite","String","Date","isNaN","getTime","toLocaleDateString","undefined","year","month","day","timeZone","JSON","parse","Array","isArray","map","join","Object","entries","key","variableScope","variables","scope","values","name","resolveBindings","functions","withVariableIds","replace","_token","id","withFunctions","token","rawName","rawArgs","definition","trim","argValues","split","argument","filter","length","args","parameters","forEach","parameter","index","result","globals","ok","hasBindings","test","FUNCTION_WIDGET_COMPONENT_ID","FUNCTION_SCOPE_COMPONENT_ID","FUNCTION_RUNNING_COMPONENT_IDS","Set","functionGlobals","prototype","hasOwnProperty","call","attachFunctionDefinitions","nodes","keys","next","node","has","componentId","props","functionName","resolveNodesBindings","changed","nextProps"],"mappings":"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"}

package/src/lib/app-utils/video-asset-facts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A placed film's length, shape and poster, read from the DAM asset as it is
+ * NOW rather than as it was when it was picked (AGL-2807).
+ *
+ * The film-only face of `media-asset-facts.ts`, which owns the rule, the
+ * reasons for it, where a document is read from, which reads answer, and the
+ * same overlay for images (AGL-2833). Everything here is that module
+ * restricted to Video nodes: an image in the map is neither listed nor
+ * rewritten, and an answer carries a film's records only. It serves a caller
+ * that lays only a film's facts over a tree.
+ */
+import { type MediaAssetDocument, type MediaAssetFacts } from './media-asset-facts';
+import type { MediaRef } from './media-ref';
+/** What a readable film's media document records, as the overlay consumes it. */
+export type VideoAssetFacts = Pick<MediaAssetFacts, 'video' | 'poster'>;
+/** A film's media document, read the way every placed asset's is. */
+export type VideoAssetDocument = MediaAssetDocument;
+/**
+ * The key a film's facts are filed under: the reference's own scope and id.
+ * One key for either element, see {@link mediaAssetFactsKey}.
+ */
+export declare function videoAssetFactsKey(ref: Pick<MediaRef, 'scope' | 'mediaId'>): string;
+/**
+ * Where a film's media document lives. One path for either element, see
+ * {@link mediaAssetDocumentPath}.
+ */
+export declare function videoAssetDocumentPath(ref: Pick<MediaRef, 'scope' | 'mediaId'>): string | null;
+/**
+ * The film facts one read of a document yields for a placement rendered on
+ * `hostId`'s pages, or `undefined` when the placement keeps its stored props.
+ * Whether the read answers at all is {@link mediaAssetFactsFromDocument}'s
+ * verdict, the one the composition reaches for every asset a page places.
+ */
+export declare function videoAssetFactsFromDocument(document: VideoAssetDocument | null | undefined, ref: Pick<MediaRef, 'scope'>, hostId: string): VideoAssetFacts | undefined;
+/**
+ * Every distinct library film the Video nodes in a map play, in document
+ * order. `[]` for a page that places none.
+ */
+export declare function videoAssetRefs(nodes: Record<string, unknown> | null | undefined): MediaRef[];
+/**
+ * The composed map with each placed film's facts laid over its node. A film
+ * with no entry keeps its stored props, and the SAME map comes back when
+ * nothing applies.
+ */
+export declare function applyVideoAssetFacts<T extends Record<string, unknown>>(nodes: T, facts: ReadonlyMap<string, VideoAssetFacts>): T;

package/src/lib/app-utils/video-asset-facts.js

@@ -0,0 +1,70 @@
+/**
+ * @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.
+ */ /**
+ * A placed film's length, shape and poster, read from the DAM asset as it is
+ * NOW rather than as it was when it was picked (AGL-2807).
+ *
+ * The film-only face of `media-asset-facts.ts`, which owns the rule, the
+ * reasons for it, where a document is read from, which reads answer, and the
+ * same overlay for images (AGL-2833). Everything here is that module
+ * restricted to Video nodes: an image in the map is neither listed nor
+ * rewritten, and an answer carries a film's records only. It serves a caller
+ * that lays only a film's facts over a tree.
+ */ import { applyMediaAssetFacts, mediaAssetDocumentPath, mediaAssetFactsFromDocument, mediaAssetFactsKey, mediaAssetRefs } from "./media-asset-facts.js";
+import { VIDEO_COMPONENT_ID } from "./video-object.js";
+/**
+ * The key a film's facts are filed under: the reference's own scope and id.
+ * One key for either element, see {@link mediaAssetFactsKey}.
+ */ export function videoAssetFactsKey(ref) {
+    return mediaAssetFactsKey(ref);
+}
+/**
+ * Where a film's media document lives. One path for either element, see
+ * {@link mediaAssetDocumentPath}.
+ */ export function videoAssetDocumentPath(ref) {
+    return mediaAssetDocumentPath(ref);
+}
+/**
+ * The film facts one read of a document yields for a placement rendered on
+ * `hostId`'s pages, or `undefined` when the placement keeps its stored props.
+ * Whether the read answers at all is {@link mediaAssetFactsFromDocument}'s
+ * verdict, the one the composition reaches for every asset a page places.
+ */ export function videoAssetFactsFromDocument(document, ref, hostId) {
+    const facts = mediaAssetFactsFromDocument(document, ref, hostId);
+    return facts && {
+        video: facts.video,
+        poster: facts.poster
+    };
+}
+/**
+ * Every distinct library film the Video nodes in a map play, in document
+ * order. `[]` for a page that places none.
+ */ export function videoAssetRefs(nodes) {
+    return mediaAssetRefs(nodes, {
+        only: VIDEO_COMPONENT_ID
+    });
+}
+/**
+ * The composed map with each placed film's facts laid over its node. A film
+ * with no entry keeps its stored props, and the SAME map comes back when
+ * nothing applies.
+ */ export function applyVideoAssetFacts(nodes, facts) {
+    return applyMediaAssetFacts(nodes, facts, {
+        only: VIDEO_COMPONENT_ID
+    });
+}
+
+//# sourceMappingURL=video-asset-facts.js.map

package/src/lib/app-utils/video-asset-facts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/video-asset-facts.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 * A placed film's length, shape and poster, read from the DAM asset as it is\n * NOW rather than as it was when it was picked (AGL-2807).\n *\n * The film-only face of `media-asset-facts.ts`, which owns the rule, the\n * reasons for it, where a document is read from, which reads answer, and the\n * same overlay for images (AGL-2833). Everything here is that module\n * restricted to Video nodes: an image in the map is neither listed nor\n * rewritten, and an answer carries a film's records only. It serves a caller\n * that lays only a film's facts over a tree.\n */\n\nimport {\n  applyMediaAssetFacts,\n  type MediaAssetDocument,\n  type MediaAssetFacts,\n  mediaAssetDocumentPath,\n  mediaAssetFactsFromDocument,\n  mediaAssetFactsKey,\n  mediaAssetRefs,\n} from './media-asset-facts'\nimport type { MediaRef } from './media-ref'\nimport { VIDEO_COMPONENT_ID } from './video-object'\n\n/** What a readable film's media document records, as the overlay consumes it. */\nexport type VideoAssetFacts = Pick<MediaAssetFacts, 'video' | 'poster'>\n\n/** A film's media document, read the way every placed asset's is. */\nexport type VideoAssetDocument = MediaAssetDocument\n\n/**\n * The key a film's facts are filed under: the reference's own scope and id.\n * One key for either element, see {@link mediaAssetFactsKey}.\n */\nexport function videoAssetFactsKey(\n  ref: Pick<MediaRef, 'scope' | 'mediaId'>,\n): string {\n  return mediaAssetFactsKey(ref)\n}\n\n/**\n * Where a film's media document lives. One path for either element, see\n * {@link mediaAssetDocumentPath}.\n */\nexport function videoAssetDocumentPath(\n  ref: Pick<MediaRef, 'scope' | 'mediaId'>,\n): string | null {\n  return mediaAssetDocumentPath(ref)\n}\n\n/**\n * The film facts one read of a document yields for a placement rendered on\n * `hostId`'s pages, or `undefined` when the placement keeps its stored props.\n * Whether the read answers at all is {@link mediaAssetFactsFromDocument}'s\n * verdict, the one the composition reaches for every asset a page places.\n */\nexport function videoAssetFactsFromDocument(\n  document: VideoAssetDocument | null | undefined,\n  ref: Pick<MediaRef, 'scope'>,\n  hostId: string,\n): VideoAssetFacts | undefined {\n  const facts = mediaAssetFactsFromDocument(document, ref, hostId)\n  return facts && { video: facts.video, poster: facts.poster }\n}\n\n/**\n * Every distinct library film the Video nodes in a map play, in document\n * order. `[]` for a page that places none.\n */\nexport function videoAssetRefs(\n  nodes: Record<string, unknown> | null | undefined,\n): MediaRef[] {\n  return mediaAssetRefs(nodes, { only: VIDEO_COMPONENT_ID })\n}\n\n/**\n * The composed map with each placed film's facts laid over its node. A film\n * with no entry keeps its stored props, and the SAME map comes back when\n * nothing applies.\n */\nexport function applyVideoAssetFacts<T extends Record<string, unknown>>(\n  nodes: T,\n  facts: ReadonlyMap<string, VideoAssetFacts>,\n): T {\n  return applyMediaAssetFacts(nodes, facts, { only: VIDEO_COMPONENT_ID })\n}\n"],"names":["applyMediaAssetFacts","mediaAssetDocumentPath","mediaAssetFactsFromDocument","mediaAssetFactsKey","mediaAssetRefs","VIDEO_COMPONENT_ID","videoAssetFactsKey","ref","videoAssetDocumentPath","videoAssetFactsFromDocument","document","hostId","facts","video","poster","videoAssetRefs","nodes","only","applyVideoAssetFacts"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;CAUC,GAED,SACEA,oBAAoB,EAGpBC,sBAAsB,EACtBC,2BAA2B,EAC3BC,kBAAkB,EAClBC,cAAc,QACT,yBAAqB;AAE5B,SAASC,kBAAkB,QAAQ,oBAAgB;AAQnD;;;CAGC,GACD,OAAO,SAASC,mBACdC,GAAwC;IAExC,OAAOJ,mBAAmBI;AAC5B;AAEA;;;CAGC,GACD,OAAO,SAASC,uBACdD,GAAwC;IAExC,OAAON,uBAAuBM;AAChC;AAEA;;;;;CAKC,GACD,OAAO,SAASE,4BACdC,QAA+C,EAC/CH,GAA4B,EAC5BI,MAAc;IAEd,MAAMC,QAAQV,4BAA4BQ,UAAUH,KAAKI;IACzD,OAAOC,SAAS;QAAEC,OAAOD,MAAMC,KAAK;QAAEC,QAAQF,MAAME,MAAM;IAAC;AAC7D;AAEA;;;CAGC,GACD,OAAO,SAASC,eACdC,KAAiD;IAEjD,OAAOZ,eAAeY,OAAO;QAAEC,MAAMZ;IAAmB;AAC1D;AAEA;;;;CAIC,GACD,OAAO,SAASa,qBACdF,KAAQ,EACRJ,KAA2C;IAE3C,OAAOZ,qBAAqBgB,OAAOJ,OAAO;QAAEK,MAAMZ;IAAmB;AACvE"}

package/src/lib/app-utils/video-object.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @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.
+ */
+/** Component id of the Video element. Persisted in documents; never renamed. */
+export declare const VIDEO_COMPONENT_ID = "video";
+/** A node as the composed map holds it — flat, children by id. */
+interface ComposedVideoNode {
+    componentId?: string;
+    props?: Record<string, unknown>;
+    resolvedProps?: Record<string, unknown>;
+}
+export interface VideoObjectContext {
+    /** The site's public origin — a relative URL is not a `contentUrl`. */
+    origin?: string | null;
+    /** The site being rendered, which qualifies an org-scoped media scope. */
+    hostId?: string;
+}
+/**
+ * The `VideoObject` for one Video node, or `undefined` when the author has not
+ * given it enough to be worth publishing.
+ *
+ * `props` precedence is `resolvedProps ?? props` — the same rule every other
+ * consumer of the composed map uses, because a node inside a repeated
+ * collection carries its bound values only in the resolved copy.
+ *
+ * URLs go through `absoluteMediaSrc` and `mediaVariantSrc`, never through the
+ * stored value: a `media:` reference published into structured data is a
+ * string no crawler can fetch, which is the AGL-1343 lesson `article-json-ld`
+ * pins for cover images.
+ */
+export declare function videoObjectJsonLd(node: ComposedVideoNode | null | undefined, context?: VideoObjectContext): Record<string, unknown> | undefined;
+/**
+ * Every publishable `VideoObject` on a page, in the composed map's own order.
+ *
+ * Returns `[]` — the common case — for a page with no video, a page whose
+ * videos have no SEO fields filled in, and a page with no nodes at all. The
+ * route then emits no extra script, which is the same shape
+ * `pageAnimationAssets` uses for the same reason.
+ *
+ * ⚠️ Hand this the map the page actually SHIPS, not the one the loader read.
+ * A video inside a withheld lazy tab panel is not in the HTML, and a
+ * `VideoObject` describing a player that is not on the page is precisely the
+ * mismatch a video rich result is checked for.
+ *
+ * ## Only the videos the page draws (AGL-2957)
+ *
+ * Being in the map is not being on the page. The renderer starts at
+ * {@link NODE_ROOT_ID} and follows child id lists, and nothing else, so a node
+ * no list names is carried in the payload and never drawn. Composition leaves
+ * such nodes on purpose: `expandCollectionEntries` and `expandRepeatables`
+ * point a block's list at its clones and keep the template in the map. On a
+ * list page that template publishes a block named `{{entry.title}}`; on an
+ * entry page, where entry tokens are substituted across the whole map, it
+ * publishes a copy of the page's own film.
+ *
+ * So when the map has a root, a Video counts only if a child list reaches it
+ * from there. Every stage that moves a subtree does so through those lists —
+ * a layout slot adopts the screen's top-level ids, a reusable component or a
+ * placed form hands its definition's list to the placement, a tab panel lists
+ * its content — so each of those is followed by the same walk, and a panel
+ * the route withheld has already lost its list. `parentId` is never followed:
+ * a template keeps its parent's id after its parent stops listing it.
+ *
+ * A map with no root is a fragment with no entry point to measure reach from,
+ * and keeps the whole-map walk.
+ *
+ * One rule of the renderer's is not in the map: a self-closing element draws
+ * no children, and which components are self-closing is registry knowledge.
+ * The editor refuses a child under one (`nodeAcceptsChildren`), so a Video
+ * there is a hand-edited document rather than an authored page.
+ *
+ * The reach is computed only for a map that holds a Video at all, so a page
+ * without one costs a single pass over its values and no walk.
+ */
+export declare function pageVideoObjects(nodes: Record<string, unknown> | null | undefined, context?: VideoObjectContext): Record<string, unknown>[];
+export {};