@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/runtime/ai-node-tree.js

@@ -0,0 +1,931 @@
+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.
+ */ import { AI_TEXT_LIMITS, isHeadlineVariant, nodeCapabilityProps } from "./ai-palette.js";
+import { AI_NODE_CAPABILITIES, AI_PALETTE, AI_SURFACES, AI_SX_TOKENS } from "./ai-palette.generated.js";
+import { linealRelationshipPermits } from "@aglyn/aglyn/app-utils/lineal-order";
+import { NODE_MAP_MAX_BYTES, nodeMapBytes } from "@aglyn/aglyn/app-utils/measure-node-map";
+import { parseMediaRef } from "@aglyn/aglyn/app-utils/media-ref";
+import { COMPONENT_PROP_NAME_PATTERN, REUSABLE_INSTANCE_COMPONENT_ID, REUSABLE_INSTANCE_PROP_VALUES_KEY } from "@aglyn/aglyn/app-utils/reusable-component-keys";
+import { createIdUrlSafe } from "@aglyn/aglyn/foundation/constants/app";
+import { CANVAS_ROOT_ELEMENT_ID } from "@aglyn/aglyn/foundation/constants/canvas";
+import { NodeType } from "@aglyn/aglyn/types/nodes";
+import { AI_COMPONENT_VISIBILITY_PROPS, isAiComponentPropToken } from "./ai-component-bindings.js";
+import { sanitizeMarketplaceDefinition } from "@aglyn/aglyn/app-utils/node-definition-sanitizer";
+/**
+ * `sx` keys a model may set: spacing, color, typography, layout, borders,
+ * display, flex and grid. Fixed rather than derived — MUI's system accepts
+ * far more (pseudo-selectors, nested selectors, arbitrary CSS properties)
+ * and every one of those is a way to reach outside the element.
+ */ export const AI_SX_ALLOWED_KEYS = new Set([
+    // spacing
+    'm',
+    'mt',
+    'mr',
+    'mb',
+    'ml',
+    'mx',
+    'my',
+    'margin',
+    'marginTop',
+    'marginRight',
+    'marginBottom',
+    'marginLeft',
+    'p',
+    'pt',
+    'pr',
+    'pb',
+    'pl',
+    'px',
+    'py',
+    'padding',
+    'paddingTop',
+    'paddingRight',
+    'paddingBottom',
+    'paddingLeft',
+    'gap',
+    'rowGap',
+    'columnGap',
+    // color
+    'color',
+    'bgcolor',
+    'backgroundColor',
+    'borderColor',
+    'opacity',
+    // typography
+    'typography',
+    'fontSize',
+    'fontWeight',
+    'fontFamily',
+    'fontStyle',
+    'lineHeight',
+    'letterSpacing',
+    'textAlign',
+    'textTransform',
+    'textDecoration',
+    'whiteSpace',
+    'textOverflow',
+    'overflowWrap',
+    'wordBreak',
+    // layout
+    'width',
+    'minWidth',
+    'maxWidth',
+    'height',
+    'minHeight',
+    'maxHeight',
+    'boxSizing',
+    'overflow',
+    'overflowX',
+    'overflowY',
+    'position',
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'zIndex',
+    'aspectRatio',
+    'objectFit',
+    // borders
+    'border',
+    'borderTop',
+    'borderRight',
+    'borderBottom',
+    'borderLeft',
+    'borderWidth',
+    'borderStyle',
+    'borderRadius',
+    'boxShadow',
+    // display
+    'display',
+    'visibility',
+    // flex
+    'flexDirection',
+    'flexWrap',
+    'justifyContent',
+    'alignItems',
+    'alignContent',
+    'alignSelf',
+    'justifySelf',
+    'flex',
+    'flexGrow',
+    'flexShrink',
+    'flexBasis',
+    'order',
+    // grid
+    'gridTemplateColumns',
+    'gridTemplateRows',
+    'gridColumn',
+    'gridRow',
+    'gridArea',
+    'gridAutoFlow',
+    'gridAutoColumns',
+    'gridAutoRows',
+    'justifyItems',
+    'placeItems',
+    'placeContent'
+]);
+/**
+ * Substrings no string a model wrote may carry, in a prop or an `sx` value.
+ * Exported for the theme tool's component style values (AGL-2938), which are
+ * the same kind of CSS value written into a theme instead of a node.
+ */ export const HOSTILE_TEXT = /<\s*\/?\s*(script|iframe|object|embed|svg|style|link|meta|base|frame|form|input|img)\b|javascript:|vbscript:|data:text\/html|expression\s*\(|url\s*\(|@import|!important|\bon[a-z]+\s*=/i;
+/**
+ * A CSS value a model may write into `sx`: lengths, numbers, keywords,
+ * shorthands (`1px solid`), functions with plain arguments (`repeat(3, 1fr)`,
+ * `rgba(0, 0, 0, 0.2)`), hex colors and theme tokens. No quotes, no
+ * semicolons, no braces, no angle brackets, no colons — which is what keeps
+ * a `url(`, a selector or a second declaration out.
+ */ export const SX_VALUE = /^[A-Za-z0-9#.,%()\s\-_/+*]{1,100}$/;
+/**
+ * Node fields the sanitizer strips that a model has no business writing —
+ * each is a way to reach past the node's own box, and each is named in
+ * `repairs` so a route can tell the model what it lost.
+ */ const STRIPPED_NODE_KEYS = [
+    'className',
+    'interactions',
+    'styleOverrides',
+    'attrOverrides',
+    'presetRef'
+];
+const SCREEN_ID = /^[A-Za-z0-9_-]{1,64}$/;
+/** The field an icon is picked with; its value carries a drawing no model can write. */ const ICON_PICKER_FIELD = 'icon-picker';
+const MAX_SX_KEYS = 40;
+/** A string prop with no role of its own — a color, a CSS length, an icon id. */ const PLAIN_STRING_MAX = 500;
+const paletteTokens = new Set(AI_SX_TOKENS.palette);
+const breakpoints = new Set(AI_SX_TOKENS.breakpoints);
+const typographyVariants = new Set(AI_SX_TOKENS.typographyVariants);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** An `https:` address that parses as one. */ export function isHttpsUrl(value) {
+    if (!/^https:\/\//i.test(value)) return false;
+    try {
+        return new URL(value).protocol === 'https:';
+    } catch (unused) {
+        return false;
+    }
+}
+/** A path on this site: one leading slash, never a scheme-relative `//`. */ export function isRootRelativePath(value) {
+    return /^\/(?!\/)[^\s<>"'`\\]*$/.test(value);
+}
+function sxValueAllowed(key, value) {
+    if (typeof value === 'number') return Number.isFinite(value);
+    if (typeof value !== 'string') return false;
+    const trimmed = value.trim();
+    if (!trimmed || HOSTILE_TEXT.test(trimmed)) return false;
+    if (paletteTokens.has(trimmed)) return true;
+    if (key === 'typography' && typographyVariants.has(trimmed)) return true;
+    return SX_VALUE.test(trimmed);
+}
+/**
+ * The allowed slice of an `sx` object, with a line per key or value dropped.
+ * Responsive objects keep only breakpoint keys; anything deeper — a
+ * pseudo-selector, a nested selector, an array — is not a value at all.
+ */ function sanitizeSx(nodeId, sx, repairs) {
+    if (!isRecord(sx)) {
+        if (sx !== undefined) repairs.push(`${nodeId}: sx is not an object; dropped`);
+        return undefined;
+    }
+    const out = {};
+    let kept = 0;
+    for (const [key, value] of Object.entries(sx)){
+        if (!AI_SX_ALLOWED_KEYS.has(key)) {
+            repairs.push(`${nodeId}: sx.${key} is not an allowed style; dropped`);
+            continue;
+        }
+        if (kept >= MAX_SX_KEYS) {
+            repairs.push(`${nodeId}: sx.${key} is past the ${MAX_SX_KEYS}-key ceiling; dropped`);
+            continue;
+        }
+        if (isRecord(value)) {
+            const responsive = {};
+            for (const [breakpoint, inner] of Object.entries(value)){
+                if (!breakpoints.has(breakpoint)) {
+                    repairs.push(`${nodeId}: sx.${key}.${breakpoint} is not a breakpoint; dropped`);
+                    continue;
+                }
+                if (!sxValueAllowed(key, inner)) {
+                    repairs.push(`${nodeId}: sx.${key}.${breakpoint} is not an allowed value; dropped`);
+                    continue;
+                }
+                responsive[breakpoint] = typeof inner === 'string' ? inner.trim() : inner;
+            }
+            if (Object.keys(responsive).length) {
+                out[key] = responsive;
+                kept += 1;
+            }
+            continue;
+        }
+        if (!sxValueAllowed(key, value)) {
+            repairs.push(`${nodeId}: sx.${key} is not an allowed value; dropped`);
+            continue;
+        }
+        out[key] = typeof value === 'string' ? value.trim() : value;
+        kept += 1;
+    }
+    return kept ? out : undefined;
+}
+function coerceEnum(schema, value) {
+    if (typeof value !== 'string' || !schema.enum) return undefined;
+    const wanted = value.trim().toLowerCase();
+    return schema.enum.find((option)=>option.toLowerCase() === wanted);
+}
+function coerceBoolean(value) {
+    if (typeof value === 'boolean') return value;
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    return undefined;
+}
+function coerceNumber(schema, value) {
+    const parsed = typeof value === 'number' ? value : typeof value === 'string' && value.trim() !== '' ? Number(value) : NaN;
+    if (!Number.isFinite(parsed)) return undefined;
+    if (schema.type === 'integer' && !Number.isInteger(parsed)) return undefined;
+    if (schema.minimum !== undefined && parsed < schema.minimum) return undefined;
+    if (schema.maximum !== undefined && parsed > schema.maximum) return undefined;
+    return parsed;
+}
+function textLimitFor(entry, name, props) {
+    const declared = entry.textLimits[name];
+    // A heading's copy is held to the headline ceiling, decided by the variant
+    // the same node carries; anything else keeps the ceiling the palette
+    // assigned to the prop.
+    if (name === 'children' && isHeadlineVariant(props.variant)) {
+        return Math.min(declared != null ? declared : AI_TEXT_LIMITS.body, AI_TEXT_LIMITS.headline);
+    }
+    return declared != null ? declared : AI_TEXT_LIMITS.body;
+}
+/**
+ * One string prop against its role. Returns the value to store, or
+ * `undefined` with the reason pushed to `repairs`. A binding token the
+ * caller admitted passes a `url` or `media` role whole.
+ */ function sanitizeString(nodeId, entry, name, schema, raw, props, screenIds, assetIds, repairs, bindingTokens = null) {
+    let value = raw.trim();
+    if (HOSTILE_TEXT.test(value)) {
+        repairs.push(`${nodeId}.${name} carried markup or script; dropped`);
+        return undefined;
+    }
+    // An icon is drawn from the path its picker stores beside the id, which a
+    // model can never supply, so an icon a model names draws nothing where the
+    // page is published (AGL-3054). The site owner picks it.
+    if (entry.propFields[name] === ICON_PICKER_FIELD) {
+        repairs.push(`${nodeId}.${name} is an icon, which the site owner picks from the library; dropped`);
+        return undefined;
+    }
+    const role = entry.propRoles[name];
+    switch(role){
+        case 'text':
+            {
+                const limit = textLimitFor(entry, name, props);
+                if (value.length > limit) {
+                    value = value.slice(0, limit).trimEnd();
+                    repairs.push(`${nodeId}.${name} was over ${limit} characters; truncated`);
+                }
+                break;
+            }
+        case 'url':
+            {
+                if (bindingTokens == null ? void 0 : bindingTokens.has(value)) break;
+                if (!isHttpsUrl(value) && !isRootRelativePath(value)) {
+                    repairs.push(`${nodeId}.${name} is neither an https: URL nor a path on this site; dropped`);
+                    return undefined;
+                }
+                break;
+            }
+        case 'screen':
+            {
+                if (screenIds ? !screenIds.has(value) : !SCREEN_ID.test(value)) {
+                    repairs.push(`${nodeId}.${name} names a screen this site does not have; dropped`);
+                    return undefined;
+                }
+                break;
+            }
+        case 'media':
+            {
+                if (bindingTokens == null ? void 0 : bindingTokens.has(value)) break;
+                if (isHttpsUrl(value)) break;
+                const ref = parseMediaRef(value);
+                if (!ref || assetIds && !assetIds.has(ref.mediaId)) {
+                    repairs.push(`${nodeId}.${name} is neither a media reference this site holds nor an https: URL; dropped`);
+                    return undefined;
+                }
+                break;
+            }
+        default:
+            {
+                if (value.length > PLAIN_STRING_MAX) {
+                    repairs.push(`${nodeId}.${name} is over ${PLAIN_STRING_MAX} characters; dropped`);
+                    return undefined;
+                }
+            }
+    }
+    if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+        repairs.push(`${nodeId}.${name} does not match its pattern; dropped`);
+        return undefined;
+    }
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        repairs.push(`${nodeId}.${name} is shorter than ${schema.minLength} characters; dropped`);
+        return undefined;
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        value = value.slice(0, schema.maxLength).trimEnd();
+        repairs.push(`${nodeId}.${name} was over ${schema.maxLength} characters; truncated`);
+    }
+    return value;
+}
+/**
+ * The element's own declarations plus the node capabilities every element
+ * carries (AGL-3156) — repeating, today. Two shapes only, so they are built
+ * once each rather than per node: a capability prop is the same on every
+ * element with the same child contract.
+ *
+ * The element wins a name collision. A component that declared a prop of its
+ * own under a capability's name would be describing its own attribute, and the
+ * validator has to hold it to that.
+ */ const CAPABLE_ENTRIES = new WeakMap();
+function withNodeCapabilities(entry) {
+    const cached = CAPABLE_ENTRIES.get(entry);
+    if (cached) return cached;
+    const capability = nodeCapabilityProps(AI_NODE_CAPABILITIES, entry.acceptsChildren);
+    const merged = _extends({}, entry, {
+        propsSchema: _extends({}, entry.propsSchema, {
+            properties: _extends({}, capability.properties, entry.propsSchema.properties)
+        }),
+        propRoles: _extends({}, capability.propRoles, entry.propRoles),
+        textLimits: _extends({}, capability.textLimits, entry.textLimits)
+    });
+    CAPABLE_ENTRIES.set(entry, merged);
+    return merged;
+}
+function sanitizeProps(nodeId, paletteEntry, raw, screenIds, assetIds, repairs, bindingTokens = null) {
+    const entry = withNodeCapabilities(paletteEntry);
+    const source = isRecord(raw) ? raw : {};
+    const props = {};
+    const declared = entry.propsSchema.properties;
+    for (const [name, value] of Object.entries(source)){
+        // `sx` is read off the node instead; a model that put it here meant the
+        // same thing, and the caller has already moved it.
+        if (name === 'sx' || value === undefined || value === null) continue;
+        const schema = declared[name];
+        if (!schema) {
+            repairs.push(`${nodeId}.${name} is not a prop of ${entry.displayName}; dropped`);
+            continue;
+        }
+        if (schema.enum) {
+            const coerced = coerceEnum(schema, value);
+            if (coerced === undefined) {
+                repairs.push(`${nodeId}.${name} is not one of ${schema.enum.join('|')}; dropped`);
+                continue;
+            }
+            if (coerced !== value) {
+                repairs.push(`${nodeId}.${name} was spelled "${String(value)}"; normalized to "${coerced}"`);
+            }
+            props[name] = coerced;
+            continue;
+        }
+        switch(schema.type){
+            case 'boolean':
+                {
+                    const coerced = coerceBoolean(value);
+                    if (coerced === undefined) {
+                        repairs.push(`${nodeId}.${name} is not a boolean; dropped`);
+                        continue;
+                    }
+                    props[name] = coerced;
+                    break;
+                }
+            case 'number':
+            case 'integer':
+                {
+                    const coerced = coerceNumber(schema, value);
+                    if (coerced === undefined) {
+                        repairs.push(`${nodeId}.${name} is not a number in range; dropped`);
+                        continue;
+                    }
+                    props[name] = coerced;
+                    break;
+                }
+            default:
+                {
+                    const text = typeof value === 'string' ? value : typeof value === 'number' || typeof value === 'boolean' ? String(value) : undefined;
+                    if (text === undefined) {
+                        repairs.push(`${nodeId}.${name} is not text; dropped`);
+                        continue;
+                    }
+                    const cleaned = sanitizeString(nodeId, entry, name, schema, text, source, screenIds, assetIds, repairs, bindingTokens);
+                    if (cleaned === undefined) continue;
+                    props[name] = cleaned;
+                }
+        }
+    }
+    for (const name of entry.propsSchema.required){
+        if (props[name] === undefined) return {
+            missing: name
+        };
+    }
+    return {
+        props
+    };
+}
+/** Surfaces that compose page elements, and so may place a component instance. */ const INSTANCE_SURFACES = new Set([
+    'screen',
+    'layout',
+    'component'
+]);
+const FORM_COMPONENT_ID = 'form';
+/** The instance prop naming the component it places; stored on every instance node. */ export const AI_INSTANCE_REF_PROP = 'refId';
+/**
+ * One value an instance fills in for a declared prop, held to what the
+ * declaration's type can hold: a picture from the library, a link, a number,
+ * a switch, or copy.
+ */ function instancePropValue(nodeId, name, type, raw, assetIds, repairs) {
+    if (type === 'number') {
+        const parsed = typeof raw === 'number' ? raw : Number(raw);
+        if (raw === '' || !Number.isFinite(parsed)) {
+            repairs.push(`${nodeId}.propValues.${name} is not a number; dropped`);
+            return undefined;
+        }
+        return parsed;
+    }
+    if (type === 'boolean') {
+        const coerced = coerceBoolean(raw);
+        if (coerced === undefined) {
+            repairs.push(`${nodeId}.propValues.${name} is not a boolean; dropped`);
+        }
+        return coerced;
+    }
+    if (type === 'icon') {
+        // A page cannot fill an icon: the pick is an id and the path drawn from
+        // it, and a word in its place draws nothing (AGL-3054). The property is
+        // left for the site owner to pick.
+        repairs.push(`${nodeId}.propValues.${name} is an icon, which the site owner picks from the library; dropped`);
+        return undefined;
+    }
+    if (typeof raw !== 'string' && typeof raw !== 'number' && typeof raw !== 'boolean') {
+        repairs.push(`${nodeId}.propValues.${name} is not a value; dropped`);
+        return undefined;
+    }
+    const value = String(raw).trim();
+    if (HOSTILE_TEXT.test(value)) {
+        repairs.push(`${nodeId}.propValues.${name} carried markup or script; dropped`);
+        return undefined;
+    }
+    if (type === 'image') {
+        if (isHttpsUrl(value)) return value;
+        const ref = parseMediaRef(value);
+        if (!ref || assetIds && !assetIds.has(ref.mediaId)) {
+            repairs.push(`${nodeId}.propValues.${name} is neither a media reference this site holds nor an https: URL; dropped`);
+            return undefined;
+        }
+        return value;
+    }
+    if (type === 'href') {
+        if (isHttpsUrl(value) || isRootRelativePath(value)) return value;
+        repairs.push(`${nodeId}.propValues.${name} is neither an https: URL nor a path on this site; dropped`);
+        return undefined;
+    }
+    if (value.length > AI_TEXT_LIMITS.body) {
+        repairs.push(`${nodeId}.propValues.${name} was over ${AI_TEXT_LIMITS.body} characters; truncated`);
+        return value.slice(0, AI_TEXT_LIMITS.body).trimEnd();
+    }
+    return value;
+}
+/**
+ * The site-record props of one node — an instance's `refId` and
+ * `propValues`, a Form's `formId` and `datasetId` — checked against the ids
+ * the caller supplied. They leave `props` before the palette pass, which
+ * would drop them as undeclared, and come back in `kept` once checked.
+ */ function sanitizeReferenceProps(nodeId, componentId, props, refs, repairs) {
+    const rest = _extends({}, props);
+    const kept = {};
+    if (componentId === REUSABLE_INSTANCE_COMPONENT_ID) {
+        var _refs_componentIds;
+        const refId = typeof rest[AI_INSTANCE_REF_PROP] === 'string' ? String(rest[AI_INSTANCE_REF_PROP]).trim() : '';
+        delete rest[AI_INSTANCE_REF_PROP];
+        if (!refId || !((_refs_componentIds = refs.componentIds) == null ? void 0 : _refs_componentIds.has(refId))) {
+            return {
+                refusal: `Reusable Component (${nodeId}) names a component this site does not have`
+            };
+        }
+        kept[AI_INSTANCE_REF_PROP] = refId;
+        const rawValues = rest[REUSABLE_INSTANCE_PROP_VALUES_KEY];
+        delete rest[REUSABLE_INSTANCE_PROP_VALUES_KEY];
+        if (rawValues !== undefined && !isRecord(rawValues)) {
+            repairs.push(`${nodeId}.propValues is not an object; dropped`);
+        }
+        const declared = refs.componentProps[refId];
+        const values = {};
+        for (const [name, raw] of Object.entries(isRecord(rawValues) ? rawValues : {})){
+            var _ref;
+            if (raw === undefined || raw === null) continue;
+            if (!COMPONENT_PROP_NAME_PATTERN.test(name)) {
+                repairs.push(`${nodeId}.propValues.${name} is not a prop name; dropped`);
+                continue;
+            }
+            if (declared && !(name in declared)) {
+                repairs.push(`${nodeId}.propValues.${name} is not a prop of that component; dropped`);
+                continue;
+            }
+            if (refs.definesComponent && isAiComponentPropToken(raw)) {
+                // A property of the component being defined, handed on whole; the
+                // component step's check holds it to the kind this prop declares.
+                values[name] = raw.trim();
+                continue;
+            }
+            const value = instancePropValue(nodeId, name, (_ref = declared == null ? void 0 : declared[name]) != null ? _ref : 'text', raw, refs.assetIds, repairs);
+            if (value !== undefined) values[name] = value;
+        }
+        if (Object.keys(values).length) kept[REUSABLE_INSTANCE_PROP_VALUES_KEY] = values;
+        return {
+            props: rest,
+            kept
+        };
+    }
+    if (componentId === FORM_COMPONENT_ID) {
+        const bindings = [
+            [
+                'formId',
+                refs.formIds,
+                'form'
+            ],
+            [
+                'datasetId',
+                refs.datasetIds,
+                'dataset'
+            ]
+        ];
+        for (const [prop, ids, record] of bindings){
+            const raw = rest[prop];
+            delete rest[prop];
+            if (raw === undefined || raw === null || raw === '') continue;
+            const id = typeof raw === 'string' ? raw.trim() : '';
+            if (id && (ids == null ? void 0 : ids.has(id))) {
+                kept[prop] = id;
+            } else {
+                repairs.push(`${nodeId}.${prop} names a ${record} this site does not have; dropped`);
+            }
+        }
+    }
+    return {
+        props: rest,
+        kept
+    };
+}
+function refusalCode(error) {
+    if (/too large/i.test(error)) return 'too-large';
+    if (/cannot be published/i.test(error)) return 'component';
+    return 'structure';
+}
+/**
+ * Whether the root the model wrote is the surface's root: the canvas wrapper
+ * for a document surface (which the sanitizer exempts by the same shape), or
+ * the named component otherwise.
+ */ function rootMatches(surfaceRoot, componentId) {
+    if (surfaceRoot === 'div') {
+        return componentId == null || componentId === '' || componentId === 'div';
+    }
+    return componentId === surfaceRoot;
+}
+export function validateAiNodeTree(input, surface, context) {
+    try {
+        return validate(input, surface, context);
+    } catch (error) {
+        return {
+            ok: false,
+            code: 'invalid-input',
+            error: `The tree could not be read: ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
+/**
+ * One element's prop and style patch, held to the rules `validateAiNodeTree`
+ * holds an element it places — for an edit to an element already on the
+ * canvas, where there is no tree to validate.
+ *
+ * The same passes run: unknown props dropped, enums coerced, every string
+ * held to its role and screened for markup, `sx` held to the key set and the
+ * value grammar. The one difference is `required`: a patch is merged over the
+ * props the element already has, so a required prop the patch does not name
+ * is not missing.
+ */ export function validateAiNodePatch(componentId, patch, context) {
+    const entry = AI_PALETTE[componentId];
+    if (!entry) {
+        return {
+            ok: false,
+            code: 'component',
+            error: `Component "${componentId}" is not in the palette`
+        };
+    }
+    const repairs = [];
+    const props = sanitizeProps(componentId, _extends({}, entry, {
+        propsSchema: _extends({}, entry.propsSchema, {
+            required: []
+        })
+    }), patch.props, (context == null ? void 0 : context.screenIds) ? new Set(context.screenIds) : null, (context == null ? void 0 : context.assetIds) ? new Set(context.assetIds) : null, repairs);
+    const sx = patch.sx === undefined ? undefined : sanitizeSx(componentId, patch.sx, repairs);
+    return {
+        ok: true,
+        props: 'props' in props ? props.props : {},
+        sx,
+        repairs
+    };
+}
+function validate(input, surface, context) {
+    var _ref;
+    const definition = AI_SURFACES[surface];
+    if (!definition) {
+        return {
+            ok: false,
+            code: 'invalid-input',
+            error: `Unknown surface "${surface}"`
+        };
+    }
+    if (!isRecord(input) || typeof input.rootId !== 'string' || !isRecord(input.nodes)) {
+        return {
+            ok: false,
+            code: 'invalid-input',
+            error: 'Expected an object with a string rootId and a nodes map'
+        };
+    }
+    const rootId = input.rootId;
+    const nodes = input.nodes;
+    const root = nodes[rootId];
+    if (!isRecord(root)) {
+        return {
+            ok: false,
+            code: 'structure',
+            error: 'Definition has no root node'
+        };
+    }
+    if (!rootMatches(definition.root, root.componentId)) {
+        return {
+            ok: false,
+            code: 'root',
+            error: `A ${surface} starts with ${definition.root === 'div' ? 'the document wrapper' : `"${definition.root}"`}, not "${String(root.componentId)}"`
+        };
+    }
+    // The sanitizer keeps only the persisted node keys, and `sx` is not one of
+    // them for a listing. Read it off every node first — from the node field
+    // or from `props.sx`, which a model writes just as readily — and put it
+    // back, checked, on the nodes that survive.
+    const sxByNodeId = new Map();
+    const hiddenByNodeId = new Set();
+    for (const [id, node] of Object.entries(nodes)){
+        if (!isRecord(node)) continue;
+        const sx = node.sx !== undefined ? node.sx : isRecord(node.props) ? node.props.sx : undefined;
+        if (sx !== undefined) sxByNodeId.set(id, sx);
+        if (node.hidden === true) hiddenByNodeId.add(id);
+    }
+    // A DAM reference (a `media:` value) is not a URL the sanitizer's
+    // `src` policy admits — a listing must not carry another tenant's asset —
+    // but on the tenant's own page it is exactly what an image should name.
+    // Lift those values out before sanitizing and hand them back to the prop
+    // pass, which holds them to the asset set the caller supplied.
+    // A binding token the caller admitted (AGL-2909) is lifted the same way:
+    // `{{entry.coverImage}}` is no address the sanitizer knows, and the prop
+    // pass holds it to the tokens the caller named.
+    const bindingTokens = (context == null ? void 0 : context.bindingTokens) ? new Set(context.bindingTokens) : null;
+    // A reusable component's own property tokens (AGL-2908) are lifted too, and
+    // kept as written rather than handed back to the prop pass: `{{prop.variant}}`
+    // is no value a dropdown, a switch, an address or a visibility directive
+    // admits. Copy keeps its tokens without lifting, as the text they are.
+    const definesComponent = (context == null ? void 0 : context.definesComponent) === true;
+    const mediaByNodeId = new Map();
+    const boundByNodeId = new Map();
+    const forSanitizer = {};
+    for (const [id, node] of Object.entries(nodes)){
+        var _ref1;
+        if (!isRecord(node) || !isRecord(node.props)) {
+            forSanitizer[id] = node;
+            continue;
+        }
+        const entry = AI_PALETTE[String(node.componentId)];
+        const roles = (_ref1 = entry == null ? void 0 : entry.propRoles) != null ? _ref1 : {};
+        const props = _extends({}, node.props);
+        const lifted = {};
+        const bound = {};
+        for (const [key, value] of Object.entries(props)){
+            if (typeof value !== 'string') continue;
+            const role = roles[key];
+            if (definesComponent && isAiComponentPropToken(value) && (AI_COMPONENT_VISIBILITY_PROPS.includes(key) || (entry == null ? void 0 : entry.propsSchema.properties[key]) !== undefined && role !== 'text')) {
+                bound[key] = value.trim();
+                delete props[key];
+                continue;
+            }
+            if (role === 'media' && parseMediaRef(value.trim()) || (role === 'media' || role === 'url') && (bindingTokens == null ? void 0 : bindingTokens.has(value.trim()))) {
+                lifted[key] = value;
+                delete props[key];
+            }
+        }
+        if (Object.keys(lifted).length) mediaByNodeId.set(id, lifted);
+        if (Object.keys(bound).length) boundByNodeId.set(id, bound);
+        forSanitizer[id] = _extends({}, node, {
+            props
+        });
+    }
+    const refs = {
+        componentIds: (context == null ? void 0 : context.componentIds) ? new Set(context.componentIds) : null,
+        componentProps: (_ref = context == null ? void 0 : context.componentProps) != null ? _ref : {},
+        formIds: (context == null ? void 0 : context.formIds) ? new Set(context.formIds) : null,
+        datasetIds: (context == null ? void 0 : context.datasetIds) ? new Set(context.datasetIds) : null,
+        assetIds: (context == null ? void 0 : context.assetIds) ? new Set(context.assetIds) : null,
+        definesComponent
+    };
+    // An instance is admitted only where the caller grounded it in the site's
+    // components; the reference itself is checked on the node below.
+    const allow = refs.componentIds && INSTANCE_SURFACES.has(surface) ? [
+        ...definition.allow,
+        REUSABLE_INSTANCE_COMPONENT_ID
+    ] : definition.allow;
+    const sanitized = sanitizeMarketplaceDefinition({
+        rootId,
+        nodes: forSanitizer
+    }, {
+        componentIds: allow
+    });
+    if (sanitized.ok === false) {
+        return {
+            ok: false,
+            code: refusalCode(sanitized.error),
+            error: sanitized.error
+        };
+    }
+    const screenIds = (context == null ? void 0 : context.screenIds) ? new Set(context.screenIds) : null;
+    const assetIds = refs.assetIds;
+    const repairs = [];
+    const output = {};
+    const rootIsWrapper = rootMatches('div', root.componentId) && definition.root === 'div';
+    const minted = new Map();
+    const mint = (id)=>{
+        const fresh = id === rootId && rootIsWrapper ? CANVAS_ROOT_ELEMENT_ID : createIdUrlSafe();
+        minted.set(id, fresh);
+        return fresh;
+    };
+    /** Each visited node's parent by the model's own ids, for the parentId check. */ const parentOf = new Map();
+    const queue = [
+        {
+            id: rootId,
+            parentId: null
+        }
+    ];
+    mint(rootId);
+    while(queue.length){
+        var _node_nodes;
+        const { id, parentId } = queue.shift();
+        const node = sanitized.nodes[id];
+        const entry = AI_PALETTE[node.componentId];
+        if (!entry) {
+            return {
+                ok: false,
+                code: 'component',
+                error: `Component "${node.componentId}" is not in the palette`
+            };
+        }
+        const newId = minted.get(id);
+        const raw = nodes[id];
+        if (isRecord(raw)) {
+            // The sanitizer drops silently; the model is told what went.
+            for (const key of STRIPPED_NODE_KEYS){
+                if (raw[key] !== undefined) {
+                    repairs.push(`${id}.${key} is not something a generated node may set; dropped`);
+                }
+            }
+            if (raw.hidden !== undefined && typeof raw.hidden !== 'boolean') {
+                repairs.push(`${id}.hidden is not a boolean; dropped`);
+            }
+            if (raw.nodes !== undefined && !Array.isArray(raw.nodes)) {
+                repairs.push(`${id}.nodes is not a list of child ids; its children were dropped`);
+            }
+            if (raw.parentId !== undefined && raw.parentId !== null && raw.parentId !== (parentId === null ? null : parentOf.get(id))) {
+                repairs.push(`${id}.parentId disagreed with where the tree places it; recomputed`);
+            }
+            if (isRecord(raw.props)) {
+                var _mediaByNodeId_get, _boundByNodeId_get;
+                const lifted = (_mediaByNodeId_get = mediaByNodeId.get(id)) != null ? _mediaByNodeId_get : {};
+                const kept = (_boundByNodeId_get = boundByNodeId.get(id)) != null ? _boundByNodeId_get : {};
+                for (const key of Object.keys(raw.props)){
+                    var _node_props;
+                    if (key !== 'sx' && lifted[key] === undefined && kept[key] === undefined && ((_node_props = node.props) == null ? void 0 : _node_props[key]) === undefined && raw.props[key] !== undefined) {
+                        repairs.push(`${id}.${key} was an unsafe handler, address or markup; dropped`);
+                    }
+                }
+            }
+        }
+        const children = [];
+        for (const childId of (_node_nodes = node.nodes) != null ? _node_nodes : []){
+            if (minted.has(childId)) {
+                repairs.push(`${childId} was listed under more than one parent; the later listing was dropped`);
+                continue;
+            }
+            const child = sanitized.nodes[childId];
+            if (!child) continue;
+            const childEntry = AI_PALETTE[child.componentId];
+            if (!childEntry) {
+                return {
+                    ok: false,
+                    code: 'component',
+                    error: `Component "${child.componentId}" is not in the palette`
+                };
+            }
+            if (!entry.acceptsChildren) {
+                return {
+                    ok: false,
+                    code: 'lineage',
+                    error: `${entry.displayName} (${id}) cannot hold other elements, but lists ${childId}`
+                };
+            }
+            if (!linealRelationshipPermits({
+                componentId: child.componentId,
+                pluginId: childEntry.pluginId,
+                restrictParent: childEntry.restrictParent
+            }, {
+                componentId: node.componentId,
+                pluginId: entry.pluginId,
+                restrictChildren: entry.restrictChildren
+            })) {
+                return {
+                    ok: false,
+                    code: 'lineage',
+                    error: `${childEntry.displayName} (${childId}) cannot be placed inside ${entry.displayName} (${id})`
+                };
+            }
+            children.push(mint(childId));
+            parentOf.set(childId, id);
+            queue.push({
+                id: childId,
+                parentId: newId
+            });
+        }
+        const reference = sanitizeReferenceProps(id, node.componentId, _extends({}, node.props, mediaByNodeId.get(id)), refs, repairs);
+        if ('refusal' in reference) {
+            return {
+                ok: false,
+                code: 'reference',
+                error: reference.refusal
+            };
+        }
+        // A required prop the component binds is present: its value is the token.
+        const boundProps = boundByNodeId.get(id);
+        const propsResult = sanitizeProps(id, boundProps ? _extends({}, entry, {
+            propsSchema: _extends({}, entry.propsSchema, {
+                required: entry.propsSchema.required.filter((name)=>boundProps[name] === undefined)
+            })
+        }) : entry, reference.props, screenIds, assetIds, repairs, bindingTokens);
+        if ('missing' in propsResult) {
+            return {
+                ok: false,
+                code: 'required-prop',
+                error: `${entry.displayName} (${id}) is missing its required "${propsResult.missing}" prop`
+            };
+        }
+        const sx = sanitizeSx(id, sxByNodeId.get(id), repairs);
+        output[newId] = _extends({
+            $id: newId,
+            type: NodeType.NODE,
+            componentId: node.componentId,
+            pluginId: entry.pluginId,
+            parentId,
+            nodes: children,
+            props: _extends({}, propsResult.props, reference.kept, boundProps)
+        }, sx ? {
+            sx
+        } : {}, hiddenByNodeId.has(id) ? {
+            hidden: true
+        } : {});
+    }
+    // The save's own measurement (msgpack), not a JSON string length: the
+    // ceiling is stated in those bytes, and a UTF-16 length reads multi-byte
+    // copy as smaller than the document the save will refuse.
+    const bytes = nodeMapBytes(output);
+    if (bytes > NODE_MAP_MAX_BYTES) {
+        return {
+            ok: false,
+            code: 'too-large',
+            error: `The tree is ${bytes} bytes; the stored ceiling is ${NODE_MAP_MAX_BYTES}`
+        };
+    }
+    const sourceIds = {};
+    for (const [source, fresh] of minted)sourceIds[fresh] = source;
+    return {
+        ok: true,
+        rootId: minted.get(rootId),
+        nodes: output,
+        repairs,
+        sourceIds
+    };
+}
+
+//# sourceMappingURL=ai-node-tree.js.map