@antglobal/copilot-cards-core 1.0.5 → 1.0.7

package/dist/validation-text.js

@@ -0,0 +1,1293 @@
+import { parseTree, getNodeValue, createScanner, printParseErrorCode, getLocation, findNodeAtLocation } from 'jsonc-parser';
+
+/**
+ * Legacy Schema Compatibility — converts old-format card JSON into
+ * the current CardSchema format so it can be rendered by the SDK.
+ *
+ * Old format:
+ * ```json
+ * {
+ *   "cardType": "common",
+ *   "cardContents": [{ "type": "text", "content": { "text": "hello" } }],
+ *   "text": "card text",
+ *   "extInfo": { "language": "zh-CN" }
+ * }
+ * ```
+ *
+ * Usage:
+ * ```ts
+ * import { convertLegacySchema } from '@antglobal/copilot-cards-core';
+ * const schema = convertLegacySchema(oldJson);
+ * renderCard(container, schema);
+ * ```
+ */
+// ─── Detection ──────────────────────────────────────────────────
+/**
+ * Detect whether an unknown input is a legacy card schema.
+ *
+ * Checks for the presence of legacy-specific fields (`cardContents`, `cardType`)
+ * and the absence of new-format fields (`rootID`, `elements`).
+ */
+function isLegacySchema(input) {
+    if (input == null || typeof input !== 'object')
+        return false;
+    const obj = input;
+    return ('cardContents' in obj &&
+        'cardType' in obj &&
+        !('rootID' in obj) &&
+        !('elements' in obj));
+}
+// ─── ID Generator ───────────────────────────────────────────────
+let _idCounter = 0;
+function uid(prefix = 'el') {
+    return `${prefix}_${++_idCounter}`;
+}
+/** Reset counter (useful for deterministic tests). */
+function resetIdCounter() {
+    _idCounter = 0;
+}
+// ─── Type Mapping ───────────────────────────────────────────────
+/**
+ * Map legacy component type names to new schema type names.
+ * Extensible — add more mappings as new component types are built.
+ */
+const TYPE_MAP = {
+    text: 'Text',
+    button: 'Button',
+    image: 'Image',
+    form: 'Form',
+    timeline: 'Timeline',
+    group: 'ColumnSet',
+    custom: 'Custom',
+};
+function mapType(legacyType) {
+    return TYPE_MAP[legacyType] ?? legacyType;
+}
+// ─── Content → Props Converters ─────────────────────────────────
+/**
+ * Convert a legacy `text` content item to ElementNode props.
+ *
+ * Legacy text content may look like:
+ * ```json
+ * { "text": "hello", "color": "red", "fontSize": 16, "bold": true, ... }
+ * ```
+ */
+function convertTextContent(content) {
+    const { text, color, fontSize, fontWeight, bold, align, maxLines, style, ...rest } = content;
+    const props = { ...rest };
+    // content field
+    if (text != null) {
+        props.content = staticValue(String(text));
+    }
+    // Merge style
+    const mergedStyle = { ...style };
+    if (color)
+        mergedStyle.color = color;
+    if (fontSize)
+        mergedStyle.fontSize = fontSize;
+    if (fontWeight)
+        mergedStyle.fontWeight = fontWeight;
+    if (bold)
+        mergedStyle.fontWeight = 'bold';
+    if (align)
+        mergedStyle.textAlign = align;
+    if (Object.keys(mergedStyle).length > 0) {
+        props.style = mergedStyle;
+    }
+    if (maxLines)
+        props.maxLines = maxLines;
+    return props;
+}
+/**
+ * Convert a legacy `button` content item to ElementNode props.
+ *
+ * Legacy button content may look like:
+ * ```json
+ * { "label": "Submit", "url": "https://...", "style": { ... } }
+ * ```
+ */
+function convertButtonContent(content) {
+    const { label, text, url, actionType: _actionType, style, ...rest } = content;
+    const props = { ...rest };
+    // Button display text
+    const displayText = label ?? text;
+    if (displayText != null) {
+        props.content = staticValue(String(displayText));
+    }
+    if (style)
+        props.style = style;
+    // Convert URL / action to events
+    let events;
+    if (url) {
+        events = {
+            onClick: [{ type: 'url', params: { url } }],
+        };
+    }
+    return { props, events };
+}
+/**
+ * Convert a legacy `image` content item to ElementNode props.
+ *
+ * Legacy image content may look like:
+ * ```json
+ * { "src": "https://...", "alt": "desc", "width": 200, "height": 100 }
+ * ```
+ */
+function convertImageContent(content) {
+    const { src, url, alt, width, height, style, ...rest } = content;
+    const props = { ...rest };
+    props.src = src ?? url;
+    if (alt)
+        props.alt = alt;
+    const mergedStyle = { ...style };
+    if (width)
+        mergedStyle.width = width;
+    if (height)
+        mergedStyle.height = height;
+    if (Object.keys(mergedStyle).length > 0) {
+        props.style = mergedStyle;
+    }
+    return props;
+}
+/**
+ * Convert a legacy `form` content item to ElementNode props.
+ * Passes through all content properties as props.
+ */
+function convertFormContent(content) {
+    return { ...content };
+}
+/**
+ * Generic fallback converter — passes content through as props.
+ */
+function convertGenericContent(content) {
+    return { ...content };
+}
+// ─── Main Converter ─────────────────────────────────────────────
+/**
+ * Convert a legacy CardSchema to the current CardSchema format.
+ *
+ * @example
+ * ```ts
+ * const newSchema = convertLegacySchema(oldJson);
+ * renderCard(container, newSchema);
+ * ```
+ */
+function convertLegacySchema(legacy) {
+    resetIdCounter();
+    const elements = {};
+    // Normalise cardContents to array
+    const contents = Array.isArray(legacy.cardContents)
+        ? legacy.cardContents
+        : [legacy.cardContents];
+    // Convert each content item, collecting top-level child IDs
+    const childIds = [];
+    for (const item of contents) {
+        const converted = convertContentItem(item, elements, legacy.tracking);
+        childIds.push(converted.id);
+    }
+    // Create root container element
+    const rootId = uid('root');
+    if (childIds.length === 1) {
+        // Single child — promote it as root directly
+        const onlyChild = elements[childIds[0]];
+        onlyChild.id = rootId;
+        delete elements[childIds[0]];
+        elements[rootId] = onlyChild;
+    }
+    else {
+        // Multiple children — wrap in a ColumnSet container
+        elements[rootId] = {
+            id: rootId,
+            type: 'ColumnSet',
+            props: {
+                slots: {
+                    default: { children: childIds },
+                },
+            },
+        };
+    }
+    // Build variables from legacy metadata
+    const variables = {
+        _legacy: {
+            cardType: legacy.cardType,
+            cardName: legacy.cardName,
+            text: legacy.text,
+            description: legacy.description,
+            language: legacy.extInfo?.language,
+            extInfo: legacy.extInfo,
+        },
+    };
+    return {
+        version: '1.0',
+        rootID: rootId,
+        elements,
+        variables,
+    };
+}
+// ─── Recursive Item Converter ───────────────────────────────────
+function convertContentItem(item, elements, tracking) {
+    const id = uid(item.type);
+    const type = mapType(item.type);
+    const content = item.content ?? {};
+    let props;
+    let events;
+    // Type-specific conversion
+    switch (item.type) {
+        case 'text':
+            props = convertTextContent(content);
+            break;
+        case 'button': {
+            const result = convertButtonContent(content);
+            props = result.props;
+            events = result.events;
+            break;
+        }
+        case 'image':
+            props = convertImageContent(content);
+            break;
+        case 'form':
+            props = convertFormContent(content);
+            break;
+        case 'group': {
+            // Group contains nested items
+            const groupChildren = Array.isArray(content.items)
+                ? content.items
+                : content.children
+                    ? (Array.isArray(content.children) ? content.children : [content.children])
+                    : [];
+            const groupChildIds = [];
+            for (const child of groupChildren) {
+                const childNode = convertContentItem(child, elements, tracking);
+                groupChildIds.push(childNode.id);
+            }
+            props = {
+                slots: {
+                    default: { children: groupChildIds },
+                },
+            };
+            // Merge groupInfo
+            if (item.groupInfo) {
+                props.groupInfo = item.groupInfo;
+            }
+            break;
+        }
+        default:
+            props = convertGenericContent(content);
+            break;
+    }
+    // Apply tracking as lifecycle / events
+    const lifecycle = convertTracking(tracking);
+    const element = {
+        id,
+        type,
+        props,
+        ...(events ? { events } : {}),
+        ...(lifecycle ? { lifecycle } : {}),
+    };
+    elements[id] = element;
+    return element;
+}
+// ─── Tracking → Lifecycle/Events ────────────────────────────────
+function convertTracking(tracking) {
+    if (!tracking)
+        return undefined;
+    const lifecycle = {};
+    if (tracking.type === 'expo') {
+        lifecycle.onExposed = [
+            {
+                type: 'emit',
+                params: { event: 'tracking', payload: { spm: tracking.spm, type: 'expo' } },
+            },
+        ];
+    }
+    if (tracking.type === 'click') {
+        // Click tracking is handled at the element level via events,
+        // but we also attach an onMount hook to register the tracking context
+        lifecycle.onMount = [
+            {
+                type: 'emit',
+                params: { event: 'tracking:register', payload: { spm: tracking.spm, type: 'click' } },
+            },
+        ];
+    }
+    return Object.keys(lifecycle).length > 0 ? lifecycle : undefined;
+}
+// ─── Helpers ────────────────────────────────────────────────────
+function staticValue(value) {
+    return { type: 'static', value };
+}
+
+const A2UI_CHILD_BINDING = Symbol('copilot-cards.a2ui-child-binding');
+/** Read adapter-owned dynamic-child metadata from a slot. */
+function getA2UIChildBinding(slot) {
+    if (!((typeof slot === 'object' && slot !== null)
+        || typeof slot === 'function')) {
+        return undefined;
+    }
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(slot, A2UI_CHILD_BINDING);
+        if (!descriptor
+            || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            return undefined;
+        }
+        return descriptor.value;
+    }
+    catch {
+        return undefined;
+    }
+}
+
+/**
+ * Schema Parser — resolves a CardSchema into a renderable tree.
+ *
+ * A CardSchema contains a flat `elements` map plus a `rootID` entry point,
+ * global `variables`, and optional global `actions`.
+ */
+// ─── Normalize ──────────────────────────────────────────────────
+/**
+ * Normalize any supported schema input into the current CardSchema.
+ *
+ * If the input is already a CardSchema, it is returned as-is.
+ * If it is a legacy format, it is automatically converted.
+ */
+function normalizeSchema(input) {
+    if (isLegacySchema(input)) {
+        return convertLegacySchema(input);
+    }
+    return input;
+}
+function encodePointerSegment$1(segment) {
+    return String(segment).replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function schemaPath(...segments) {
+    return segments.length > 0
+        ? `/${segments.map(encodePointerSegment$1).join('/')}`
+        : '';
+}
+function elementPath(id, ...segments) {
+    return schemaPath('elements', id, ...segments);
+}
+function slotPath(id, slotName, ...segments) {
+    return elementPath(id, 'props', 'slots', slotName, ...segments);
+}
+function addIssue(issues, code, path, message, params, anchorPath) {
+    issues.push({
+        code,
+        path,
+        ...(anchorPath === undefined ? {} : { anchorPath }),
+        message,
+        ...(params === undefined ? {} : { params }),
+    });
+}
+function displayValue(value) {
+    try {
+        return String(value);
+    }
+    catch {
+        return '<unprintable>';
+    }
+}
+function displayError(error) {
+    const message = readOwnData(error, 'message');
+    return displayValue(message.kind === 'value' ? message.value : error);
+}
+/**
+ * Validate an unknown schema input and return structured diagnostics.
+ *
+ * Component names and component-specific props are deliberately not checked;
+ * this validator only owns the shared card graph and binding protocol.
+ */
+function validateSchemaDetailed(input) {
+    const issues = [];
+    if (!isPlainObject(input)) {
+        addIssue(issues, 'SCHEMA_TYPE_MISMATCH', '', 'Schema must be a non-null plain object');
+        return issues;
+    }
+    let schema;
+    try {
+        schema = normalizeSchema(input);
+    }
+    catch (error) {
+        addIssue(issues, 'LEGACY_CONVERSION_FAILED', '', `Legacy schema conversion failed: ${displayError(error)}`);
+        return issues;
+    }
+    const version = readOwnData(schema, 'version');
+    if (version.kind !== 'value' || !version.value) {
+        addIssue(issues, 'SCHEMA_REQUIRED_FIELD', schemaPath('version'), 'Missing "version" field', undefined, '');
+    }
+    const rootID = readOwnData(schema, 'rootID');
+    if (rootID.kind !== 'value' || typeof rootID.value !== 'string') {
+        addIssue(issues, 'ROOT_TYPE_MISMATCH', schemaPath('rootID'), '"rootID" field must be a string', undefined, rootID.kind === 'missing' ? '' : undefined);
+    }
+    else if (!rootID.value) {
+        addIssue(issues, 'SCHEMA_REQUIRED_FIELD', schemaPath('rootID'), 'Missing "rootID" field');
+    }
+    const elementsRead = readOwnData(schema, 'elements');
+    if (elementsRead.kind === 'missing') {
+        addIssue(issues, 'SCHEMA_REQUIRED_FIELD', schemaPath('elements'), 'Missing "elements" field', undefined, '');
+        return issues;
+    }
+    const rawElements = elementsRead.kind === 'value'
+        ? elementsRead.value
+        : undefined;
+    if (!isPlainObject(rawElements)) {
+        addIssue(issues, 'SCHEMA_TYPE_MISMATCH', schemaPath('elements'), '"elements" field must be an object');
+        return issues;
+    }
+    const elements = rawElements;
+    const elementEntries = ownStringDataEntries(elements);
+    for (const id of elementEntries.accessors) {
+        addIssue(issues, 'ELEMENT_ACCESSOR_NOT_ALLOWED', elementPath(id), `Element "${id}" must be an own data property`, { elementId: id });
+    }
+    if (elementEntries.opaque) {
+        addIssue(issues, 'ELEMENTS_UNINSPECTABLE', schemaPath('elements'), 'The "elements" field could not be inspected safely');
+        return issues;
+    }
+    const allIds = new Set([
+        ...elementEntries.entries.map(([id]) => id),
+        ...elementEntries.accessors,
+    ]);
+    const validationElements = Object.create(null);
+    for (const [id, element] of elementEntries.entries) {
+        Object.defineProperty(validationElements, id, {
+            configurable: true,
+            enumerable: true,
+            value: element,
+            writable: true,
+        });
+    }
+    const validationSchema = {
+        rootID: rootID.kind === 'value' && typeof rootID.value === 'string'
+            ? rootID.value
+            : '',
+        elements: validationElements};
+    if (rootID.kind === 'value'
+        && typeof rootID.value === 'string'
+        && rootID.value
+        && !allIds.has(rootID.value)) {
+        addIssue(issues, 'ROOT_REFERENCE_NOT_FOUND', schemaPath('rootID'), `Root element "${rootID.value}" not found in elements`, { rootID: rootID.value });
+    }
+    for (const [id, rawElement] of elementEntries.entries) {
+        if (!isPlainObject(rawElement)) {
+            addIssue(issues, 'ELEMENT_TYPE_MISMATCH', elementPath(id), `Element "${id}" must be an object`, { elementId: id });
+            continue;
+        }
+        const element = rawElement;
+        const type = readOwnData(element, 'type');
+        if (type.kind !== 'value' || !type.value) {
+            addIssue(issues, 'ELEMENT_TYPE_MISSING', elementPath(id, 'type'), `Element "${id}" is missing a "type" field`, { elementId: id }, type.kind === 'missing' ? elementPath(id) : undefined);
+        }
+        const props = readOwnData(element, 'props');
+        if (props.kind !== 'value' || !isPlainObject(props.value)) {
+            addIssue(issues, 'ELEMENT_PROPS_TYPE_MISMATCH', elementPath(id, 'props'), `Element "${id}" "props" field must be an object`, { elementId: id }, props.kind === 'missing' ? elementPath(id) : undefined);
+            continue;
+        }
+        // Validate slot children and groups references without invoking accessors.
+        const rawSlots = readOwnData(props.value, 'slots');
+        if (rawSlots.kind === 'accessor' || rawSlots.kind === 'opaque') {
+            addIssue(issues, 'SLOTS_UNINSPECTABLE', elementPath(id, 'props', 'slots'), `Element "${id}" slots could not be inspected safely`, { elementId: id });
+            continue;
+        }
+        if (rawSlots.kind === 'value' && !isPlainObject(rawSlots.value)) {
+            addIssue(issues, 'SLOTS_TYPE_MISMATCH', elementPath(id, 'props', 'slots'), `Element "${id}" "slots" field must be an object`, { elementId: id });
+            continue;
+        }
+        const slots = rawSlots.kind === 'value'
+            ? ownStringDataEntries(rawSlots.value)
+            : ownStringDataEntries(undefined);
+        for (const slotName of slots.accessors) {
+            addIssue(issues, 'SLOT_ACCESSOR_NOT_ALLOWED', slotPath(id, slotName), `Element "${id}" slot "${slotName}" must be an own data property`, { elementId: id, slotName });
+        }
+        if (slots.opaque) {
+            addIssue(issues, 'SLOTS_UNINSPECTABLE', elementPath(id, 'props', 'slots'), `Element "${id}" slots could not be inspected safely`, { elementId: id });
+        }
+        for (const [slotName, slot] of slots.entries) {
+            if (!isPlainObject(slot)) {
+                addIssue(issues, 'SLOT_TYPE_MISMATCH', slotPath(id, slotName), `Element "${id}" slot "${slotName}" must be an object`, { elementId: id, slotName });
+                continue;
+            }
+            const children = readOwnData(slot, 'children');
+            if (children.kind === 'value') {
+                const values = ownArrayDataValues(children.value);
+                if (!values) {
+                    addIssue(issues, 'SLOT_CHILDREN_TYPE_MISMATCH', slotPath(id, slotName, 'children'), `Element "${id}" slot "${slotName}" children must be an array`, { elementId: id, slotName });
+                }
+                else {
+                    for (const [index, childId] of values.entries()) {
+                        if (typeof childId !== 'string' || childId.length === 0) {
+                            addIssue(issues, 'SLOT_CHILD_ID_INVALID', slotPath(id, slotName, 'children', index), `Element "${id}" slot "${slotName}" child IDs must be non-empty strings; received "${displayValue(childId)}"`, { elementId: id, slotName, value: childId });
+                        }
+                        else if (!allIds.has(childId)) {
+                            addIssue(issues, 'ELEMENT_REFERENCE_NOT_FOUND', slotPath(id, slotName, 'children', index), `Element "${id}" slot "${slotName}" references unknown child "${displayValue(childId)}"`, { elementId: id, slotName, reference: childId });
+                        }
+                    }
+                }
+            }
+            else if (children.kind === 'accessor' || children.kind === 'opaque') {
+                addIssue(issues, 'SLOT_ACCESSOR_NOT_ALLOWED', slotPath(id, slotName, 'children'), `Element "${id}" slot "${slotName}" children must be an own data property`, { elementId: id, slotName, field: 'children' });
+            }
+            const groups = readOwnData(slot, 'groups');
+            if (groups.kind === 'value') {
+                const groupValues = ownArrayDataValues(groups.value);
+                if (!groupValues) {
+                    addIssue(issues, 'SLOT_GROUPS_TYPE_MISMATCH', slotPath(id, slotName, 'groups'), `Element "${id}" slot "${slotName}" groups must be an array`, { elementId: id, slotName });
+                }
+                else {
+                    for (const [groupIndex, group] of groupValues.entries()) {
+                        const childrenInGroup = ownArrayDataValues(group);
+                        if (!childrenInGroup) {
+                            addIssue(issues, 'SLOT_GROUP_TYPE_MISMATCH', slotPath(id, slotName, 'groups', groupIndex), `Element "${id}" slot "${slotName}" groups must contain arrays`, { elementId: id, slotName });
+                            continue;
+                        }
+                        for (const [childIndex, childId] of childrenInGroup.entries()) {
+                            if (typeof childId !== 'string' || childId.length === 0) {
+                                addIssue(issues, 'SLOT_GROUP_CHILD_ID_INVALID', slotPath(id, slotName, 'groups', groupIndex, childIndex), `Element "${id}" slot "${slotName}" group child IDs must be non-empty strings; received "${displayValue(childId)}"`, { elementId: id, slotName, value: childId });
+                            }
+                            else if (!allIds.has(childId)) {
+                                addIssue(issues, 'ELEMENT_REFERENCE_NOT_FOUND', slotPath(id, slotName, 'groups', groupIndex, childIndex), `Element "${id}" slot "${slotName}" group references unknown child "${displayValue(childId)}"`, { elementId: id, slotName, reference: childId });
+                            }
+                        }
+                    }
+                }
+            }
+            else if (groups.kind === 'accessor' || groups.kind === 'opaque') {
+                addIssue(issues, 'SLOT_ACCESSOR_NOT_ALLOWED', slotPath(id, slotName, 'groups'), `Element "${id}" slot "${slotName}" groups must be an own data property`, { elementId: id, slotName, field: 'groups' });
+            }
+        }
+    }
+    validateRepeatBindings(validationSchema, issues);
+    return issues;
+}
+const REPEAT_SLOT_LAYOUTS = new Set([
+    'default',
+    'flex',
+    'list',
+    'grid',
+    'horizontalScroll',
+    'carousel',
+]);
+const ALIAS_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED_ALIASES = new Set(['__proto__', 'constructor', 'prototype']);
+function hasOwn(value, key) {
+    try {
+        return ((typeof value === 'object' && value !== null) ||
+            typeof value === 'function') && Object.prototype.hasOwnProperty.call(value, key);
+    }
+    catch {
+        return false;
+    }
+}
+function isPlainObject(value) {
+    try {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return false;
+        }
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function readOwnData(value, key) {
+    if (!((typeof value === 'object' && value !== null)
+        || typeof value === 'function')) {
+        return { kind: 'missing' };
+    }
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            return { kind: 'missing' };
+        if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            return { kind: 'accessor' };
+        }
+        return { kind: 'value', value: descriptor.value };
+    }
+    catch {
+        return { kind: 'opaque' };
+    }
+}
+function ownStringDataEntries(value) {
+    const result = {
+        entries: [],
+        accessors: [],
+        opaque: false,
+    };
+    if (!value || typeof value !== 'object')
+        return result;
+    try {
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key !== 'string')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor) {
+                result.opaque = true;
+            }
+            else if (Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+                result.entries.push([key, descriptor.value]);
+            }
+            else {
+                result.accessors.push(key);
+            }
+        }
+    }
+    catch {
+        result.opaque = true;
+    }
+    return result;
+}
+function ownArrayDataValues(value) {
+    try {
+        if (!Array.isArray(value))
+            return undefined;
+        const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+        const length = lengthDescriptor?.value;
+        if (!Number.isSafeInteger(length) || length < 0)
+            return undefined;
+        const output = [];
+        for (let index = 0; index < length; index += 1) {
+            const entry = readOwnData(value, String(index));
+            if (entry.kind !== 'value')
+                return undefined;
+            output.push(entry.value);
+        }
+        return output;
+    }
+    catch {
+        return undefined;
+    }
+}
+function elementSlotEntries(element) {
+    const props = readOwnData(element, 'props');
+    const slots = props.kind === 'value'
+        ? readOwnData(props.value, 'slots')
+        : props;
+    return slots.kind === 'value'
+        ? ownStringDataEntries(slots.value)
+        : {
+            entries: [],
+            accessors: slots.kind === 'accessor' ? ['slots'] : [],
+            opaque: slots.kind === 'opaque',
+        };
+}
+function readRepeatBindingFields(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const source = readOwnData(value, 'source');
+    const template = readOwnData(value, 'template');
+    const item = readOwnData(value, 'item');
+    const index = readOwnData(value, 'index');
+    const emptyTemplate = readOwnData(value, 'emptyTemplate');
+    return {
+        source: source.kind === 'value' ? source.value : undefined,
+        template: template.kind === 'value' ? template.value : undefined,
+        ...(item.kind === 'value' ? { item: item.value } : {}),
+        ...(index.kind === 'value' ? { index: index.value } : {}),
+        ...(emptyTemplate.kind === 'value'
+            ? { emptyTemplate: emptyTemplate.value }
+            : {}),
+    };
+}
+function slotStaticReferences(slot) {
+    const references = [];
+    const children = readOwnData(slot, 'children');
+    if (children.kind === 'value') {
+        for (const child of ownArrayDataValues(children.value) ?? []) {
+            if (typeof child === 'string')
+                references.push(child);
+        }
+    }
+    const groups = readOwnData(slot, 'groups');
+    if (groups.kind === 'value') {
+        for (const group of ownArrayDataValues(groups.value) ?? []) {
+            for (const child of ownArrayDataValues(group) ?? []) {
+                if (typeof child === 'string')
+                    references.push(child);
+            }
+        }
+    }
+    const config = readOwnData(slot, 'config');
+    const overlays = config.kind === 'value'
+        ? readOwnData(config.value, 'overlays')
+        : { kind: 'missing' };
+    if (overlays.kind === 'value') {
+        for (const overlay of ownArrayDataValues(overlays.value) ?? []) {
+            const overlayChildren = readOwnData(overlay, 'children');
+            if (overlayChildren.kind !== 'value')
+                continue;
+            for (const child of ownArrayDataValues(overlayChildren.value) ?? []) {
+                if (typeof child === 'string')
+                    references.push(child);
+            }
+        }
+    }
+    return references;
+}
+function getOwnElement(schema, id) {
+    const element = readOwnData(schema.elements, id);
+    return element.kind === 'value'
+        ? element.value
+        : undefined;
+}
+function isCompleteExpression(source) {
+    if (typeof source !== 'string')
+        return false;
+    const trimmed = source.trim();
+    if (!trimmed.startsWith('${'))
+        return false;
+    if (!trimmed.slice(2, -1).trim())
+        return false;
+    let depth = 1;
+    let quote;
+    let escaped = false;
+    for (let index = 2; index < trimmed.length; index += 1) {
+        const character = trimmed[index];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === '\\') {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === "'" || character === '"' || character === '`') {
+            quote = character;
+        }
+        else if (character === '{') {
+            depth += 1;
+        }
+        else if (character === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return index === trimmed.length - 1;
+        }
+    }
+    return false;
+}
+function elementReferences(element) {
+    const references = [];
+    for (const [, slot] of elementSlotEntries(element).entries) {
+        references.push(...slotStaticReferences(slot));
+        const repeat = readOwnData(slot, 'repeat');
+        const binding = repeat.kind === 'value'
+            ? readRepeatBindingFields(repeat.value)
+            : undefined;
+        if (typeof binding?.template === 'string' && binding.template) {
+            references.push(binding.template);
+        }
+        if (typeof binding?.emptyTemplate === 'string'
+            && binding.emptyTemplate) {
+            references.push(binding.emptyTemplate);
+        }
+        const a2ui = getA2UIChildBinding(slot);
+        if (typeof a2ui?.templateId === 'string' && a2ui.templateId) {
+            references.push(a2ui.templateId);
+        }
+    }
+    return references;
+}
+function validateRepeatBindings(schema, issues) {
+    const dynamicBindings = [];
+    for (const [id, element] of Object.entries(schema.elements)) {
+        const elementRepeats = elementSlotEntries(element).entries
+            .filter((entry) => hasOwn(entry[1], 'repeat')
+            || getA2UIChildBinding(entry[1]) !== undefined);
+        if (elementRepeats.length > 1) {
+            addIssue(issues, 'DYNAMIC_SLOT_MULTIPLE', elementPath(id, 'props', 'slots'), `Element "${id}" has more than one dynamic slot`, { elementId: id });
+        }
+        for (const [slotName, slot] of elementRepeats) {
+            const a2ui = getA2UIChildBinding(slot);
+            const repeat = readOwnData(slot, 'repeat');
+            if (repeat.kind === 'missing' && a2ui) {
+                dynamicBindings.push({
+                    owner: id,
+                    slotName,
+                    dialect: 'a2ui',
+                    template: a2ui.templateId,
+                });
+                if (typeof a2ui.templateId !== 'string'
+                    || a2ui.templateId.length === 0) {
+                    addIssue(issues, 'DYNAMIC_TEMPLATE_INVALID', slotPath(id, slotName), `Element "${id}" slot "${slotName}" dynamic children template must be a non-empty string`, { elementId: id, slotName });
+                }
+                else if (!getOwnElement(schema, a2ui.templateId)) {
+                    addIssue(issues, 'DYNAMIC_TEMPLATE_NOT_FOUND', slotPath(id, slotName), `Element "${id}" slot "${slotName}" dynamic children reference unknown template "${a2ui.templateId}"`, { elementId: id, slotName, reference: a2ui.templateId });
+                }
+                continue;
+            }
+            const rawBinding = repeat.kind === 'value'
+                ? repeat.value
+                : undefined;
+            if (!isPlainObject(rawBinding)) {
+                addIssue(issues, 'REPEAT_TYPE_MISMATCH', slotPath(id, slotName, 'repeat'), `Element "${id}" slot "${slotName}" repeat must be a non-null plain object`, { elementId: id, slotName });
+                continue;
+            }
+            const binding = readRepeatBindingFields(rawBinding);
+            dynamicBindings.push({
+                owner: id,
+                slotName,
+                dialect: 'native',
+                template: binding.template,
+                binding,
+            });
+            if (!REPEAT_SLOT_LAYOUTS.has(slotName)) {
+                addIssue(issues, 'REPEAT_SLOT_UNSUPPORTED', slotPath(id, slotName, 'repeat'), `Element "${id}" slot "${slotName}" does not support repeat`, { elementId: id, slotName });
+            }
+            const children = readOwnData(slot, 'children');
+            const groups = readOwnData(slot, 'groups');
+            if ((children.kind === 'value' && !!children.value)
+                || children.kind === 'accessor'
+                || children.kind === 'opaque'
+                || (groups.kind === 'value' && !!groups.value)
+                || groups.kind === 'accessor'
+                || groups.kind === 'opaque') {
+                addIssue(issues, 'REPEAT_CONTENT_CONFLICT', slotPath(id, slotName, 'repeat'), `Element "${id}" slot "${slotName}" cannot combine repeat with children or groups`, { elementId: id, slotName });
+            }
+            if (typeof binding.source !== 'string') {
+                addIssue(issues, 'REPEAT_SOURCE_TYPE_MISMATCH', slotPath(id, slotName, 'repeat', 'source'), `Element "${id}" slot "${slotName}" repeat source must be a string`, { elementId: id, slotName }, hasOwn(rawBinding, 'source')
+                    ? undefined
+                    : slotPath(id, slotName, 'repeat'));
+            }
+            else if (!isCompleteExpression(binding.source)) {
+                addIssue(issues, 'REPEAT_SOURCE_INVALID', slotPath(id, slotName, 'repeat', 'source'), `Element "${id}" slot "${slotName}" repeat source must be one complete non-empty \${...} expression`, { elementId: id, slotName });
+            }
+            if (typeof binding.template !== 'string') {
+                addIssue(issues, 'REPEAT_TEMPLATE_TYPE_MISMATCH', slotPath(id, slotName, 'repeat', 'template'), `Element "${id}" slot "${slotName}" repeat template must be a string`, { elementId: id, slotName }, hasOwn(rawBinding, 'template')
+                    ? undefined
+                    : slotPath(id, slotName, 'repeat'));
+            }
+            else if (!binding.template) {
+                addIssue(issues, 'REPEAT_TEMPLATE_INVALID', slotPath(id, slotName, 'repeat', 'template'), `Element "${id}" slot "${slotName}" repeat template must be a non-empty string`, { elementId: id, slotName });
+            }
+            else if (!getOwnElement(schema, binding.template)) {
+                addIssue(issues, 'REPEAT_TEMPLATE_NOT_FOUND', slotPath(id, slotName, 'repeat', 'template'), `Element "${id}" slot "${slotName}" repeat references unknown template "${binding.template}"`, { elementId: id, slotName, reference: binding.template });
+            }
+            if (binding.item !== undefined) {
+                validateAlias(id, slotName, 'item', binding.item, issues);
+            }
+            if (binding.index !== undefined) {
+                validateAlias(id, slotName, 'index', binding.index, issues);
+            }
+            if (binding.index !== undefined
+                && (binding.item ?? '$item') === binding.index) {
+                addIssue(issues, 'REPEAT_ALIAS_COLLISION', slotPath(id, slotName, 'repeat', 'index'), `Element "${id}" slot "${slotName}" repeat item and index aliases must be different`, { elementId: id, slotName, alias: binding.index });
+            }
+            if (binding.emptyTemplate !== undefined) {
+                if (typeof binding.emptyTemplate !== 'string') {
+                    addIssue(issues, 'REPEAT_EMPTY_TEMPLATE_TYPE_MISMATCH', slotPath(id, slotName, 'repeat', 'emptyTemplate'), `Element "${id}" slot "${slotName}" repeat emptyTemplate must be a string`, { elementId: id, slotName });
+                }
+                else if (!binding.emptyTemplate) {
+                    addIssue(issues, 'REPEAT_EMPTY_TEMPLATE_INVALID', slotPath(id, slotName, 'repeat', 'emptyTemplate'), `Element "${id}" slot "${slotName}" repeat emptyTemplate must be a non-empty string`, { elementId: id, slotName });
+                }
+                else if (!getOwnElement(schema, binding.emptyTemplate)) {
+                    addIssue(issues, 'REPEAT_EMPTY_TEMPLATE_NOT_FOUND', slotPath(id, slotName, 'repeat', 'emptyTemplate'), `Element "${id}" slot "${slotName}" repeat references unknown empty template "${binding.emptyTemplate}"`, { elementId: id, slotName, reference: binding.emptyTemplate });
+                }
+            }
+        }
+    }
+    validateRepeatNesting(schema, dynamicBindings, issues);
+    validateDynamicClosures(schema, dynamicBindings, issues);
+}
+function validateAlias(owner, slotName, kind, alias, issues) {
+    if (typeof alias !== 'string') {
+        addIssue(issues, 'REPEAT_ALIAS_TYPE_MISMATCH', slotPath(owner, slotName, 'repeat', kind), `Element "${owner}" slot "${slotName}" repeat ${kind} must be a string`, { elementId: owner, slotName, field: kind });
+    }
+    else if (!ALIAS_PATTERN.test(alias)) {
+        addIssue(issues, 'REPEAT_ALIAS_INVALID', slotPath(owner, slotName, 'repeat', kind), `Element "${owner}" slot "${slotName}" repeat ${kind} alias "${alias}" is invalid`, { elementId: owner, slotName, field: kind, alias });
+    }
+    else if (RESERVED_ALIASES.has(alias)) {
+        addIssue(issues, 'REPEAT_ALIAS_RESERVED', slotPath(owner, slotName, 'repeat', kind), `Element "${owner}" slot "${slotName}" repeat ${kind} alias "${alias}" is reserved`, { elementId: owner, slotName, field: kind, alias });
+    }
+}
+function validateRepeatNesting(schema, bindings, issues) {
+    const reportedCycles = new Set();
+    const reportedCollisions = new Set();
+    function effectiveAliases(binding) {
+        if (!binding)
+            return [];
+        if (binding.item !== undefined) {
+            return [binding.item, binding.index].filter((alias) => typeof alias === 'string');
+        }
+        return [
+            '$item',
+            binding.index === undefined ? '$index' : binding.index,
+        ].filter((alias) => typeof alias === 'string');
+    }
+    function visitElement(id, activeAliases, repeatPath, visitedStatic) {
+        const element = getOwnElement(schema, id);
+        if (!element || visitedStatic.has(id))
+            return;
+        const nextVisitedStatic = new Set(visitedStatic).add(id);
+        for (const [slotName, slotValue] of elementSlotEntries(element).entries) {
+            if (!slotValue || typeof slotValue !== 'object')
+                continue;
+            const slot = slotValue;
+            const repeat = readOwnData(slot, 'repeat');
+            const nativeBinding = repeat.kind === 'value'
+                ? readRepeatBindingFields(repeat.value)
+                : undefined;
+            const a2uiBinding = getA2UIChildBinding(slot);
+            const itemTemplate = nativeBinding?.template ?? a2uiBinding?.templateId;
+            const visitDynamicTemplate = (template, aliases) => {
+                if (!template)
+                    return;
+                const cycleAt = repeatPath.indexOf(template);
+                if (cycleAt >= 0) {
+                    const cycle = [...repeatPath.slice(cycleAt), template].join(' -> ');
+                    if (!reportedCycles.has(cycle)) {
+                        reportedCycles.add(cycle);
+                        addIssue(issues, nativeBinding
+                            ? 'REPEAT_TEMPLATE_CYCLE'
+                            : 'DYNAMIC_TEMPLATE_CYCLE', nativeBinding
+                            ? slotPath(id, slotName, 'repeat', 'template')
+                            : slotPath(id, slotName), nativeBinding
+                            ? `Element "${id}" slot "${slotName}" has repeat template cycle: ${cycle}`
+                            : `Element "${id}" slot "${slotName}" has dynamic template cycle: ${cycle}`, { elementId: id, slotName, cycle });
+                    }
+                    return;
+                }
+                for (const alias of aliases) {
+                    if (activeAliases.has(alias)) {
+                        const key = `${id}:${slotName}:${alias}`;
+                        if (!reportedCollisions.has(key)) {
+                            reportedCollisions.add(key);
+                            addIssue(issues, 'REPEAT_ALIAS_COLLISION', slotPath(id, slotName, 'repeat'), `Element "${id}" slot "${slotName}" repeat alias "${alias}" conflicts with an active repeat alias`, { elementId: id, slotName, alias });
+                        }
+                    }
+                }
+                const nestedAliases = new Set(activeAliases);
+                for (const alias of aliases)
+                    nestedAliases.add(alias);
+                visitElement(template, nestedAliases, [...repeatPath, template], new Set());
+            };
+            visitDynamicTemplate(itemTemplate, effectiveAliases(nativeBinding));
+            visitDynamicTemplate(nativeBinding?.emptyTemplate, []);
+            for (const child of slotStaticReferences(slot)) {
+                visitElement(child, activeAliases, repeatPath, nextVisitedStatic);
+            }
+        }
+    }
+    for (const dynamic of bindings) {
+        const { owner, binding, template } = dynamic;
+        const aliases = new Set(effectiveAliases(binding));
+        if (typeof template === 'string' && template) {
+            visitElement(template, aliases, [owner, template], new Set());
+        }
+        if (typeof binding?.emptyTemplate === 'string'
+            && binding.emptyTemplate) {
+            visitElement(binding.emptyTemplate, new Set(), [owner, binding.emptyTemplate], new Set());
+        }
+    }
+}
+function validateDynamicClosures(schema, repeats, issues) {
+    for (const { owner } of repeats) {
+        const visited = new Set();
+        function visit(id) {
+            if (visited.has(id))
+                return;
+            visited.add(id);
+            const element = getOwnElement(schema, id);
+            if (!element)
+                return;
+            const lifecycle = readOwnData(element, 'lifecycle');
+            if ((lifecycle.kind === 'value' && !!lifecycle.value)
+                || lifecycle.kind === 'accessor'
+                || lifecycle.kind === 'opaque') {
+                addIssue(issues, 'DYNAMIC_LIFECYCLE_UNSUPPORTED', elementPath(id, 'lifecycle'), `Element "${id}" in dynamic patch closure owned by "${owner}" cannot use lifecycle`, { elementId: id, owner });
+            }
+            const props = readOwnData(element, 'props');
+            if (props.kind === 'value' && hasOwn(props.value, 'variableKey')) {
+                addIssue(issues, 'DYNAMIC_VARIABLE_KEY_UNSUPPORTED', elementPath(id, 'props', 'variableKey'), `Element "${id}" in dynamic patch closure owned by "${owner}" cannot use props.variableKey`, { elementId: id, owner });
+            }
+            for (const reference of elementReferences(element))
+                visit(reference);
+        }
+        visit(owner);
+    }
+}
+
+/**
+ * Optional, editor-oriented validation for JSON source text.
+ *
+ * Kept out of the Core main entry so render-only consumers do not bundle a
+ * fault-tolerant JSON parser they never use.
+ */
+const SCHEMA_TEXT_MAX_CHARACTERS = 1000000;
+const SCHEMA_TEXT_MAX_DEPTH = 128;
+const SCHEMA_TEXT_MAX_ERRORS = 50;
+// jsonc-parser exposes these as an ambient const enum, which cannot be read
+// directly when this package is compiled with isolatedModules.
+const OPEN_BRACE_TOKEN = 1;
+const CLOSE_BRACE_TOKEN = 2;
+const OPEN_BRACKET_TOKEN = 3;
+const CLOSE_BRACKET_TOKEN = 4;
+const END_OF_FILE_TOKEN = 17;
+function encodePointerSegment(segment) {
+    return String(segment).replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function toJsonPointer(path) {
+    return path.length > 0
+        ? `/${path.map(encodePointerSegment).join('/')}`
+        : '';
+}
+function pointerSegments(pointer) {
+    if (!pointer)
+        return [];
+    if (!pointer.startsWith('/'))
+        return [];
+    return pointer.slice(1).split('/').map(segment => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+}
+function resolvePointerNode(root, segments) {
+    let current = root;
+    for (const segment of segments) {
+        if (!current)
+            return undefined;
+        const locationSegment = current.type === 'array'
+            && /^(0|[1-9]\d*)$/.test(segment)
+            ? Number(segment)
+            : segment;
+        current = findNodeAtLocation(current, [locationSegment]);
+    }
+    return current;
+}
+function lineStarts(text, endOffset = text.length) {
+    const starts = [0];
+    const end = Math.min(text.length, endOffset);
+    for (let offset = 0; offset < end; offset += 1) {
+        if (text.charCodeAt(offset) === 10)
+            starts.push(offset + 1);
+    }
+    return starts;
+}
+function positionAt(starts, textLength, rawOffset) {
+    const offset = Math.min(Math.max(rawOffset, 0), textLength);
+    let low = 0;
+    let high = starts.length;
+    while (low + 1 < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (starts[middle] <= offset)
+            low = middle;
+        else
+            high = middle;
+    }
+    return {
+        line: low + 1,
+        column: offset - starts[low] + 1,
+        offset,
+    };
+}
+function sourceRange(text, starts, rawOffset, rawLength) {
+    const offset = Math.min(Math.max(rawOffset, 0), text.length);
+    const length = rawLength > 0
+        ? rawLength
+        : (offset < text.length ? 1 : 0);
+    const endOffset = Math.min(offset + length, text.length);
+    return {
+        start: positionAt(starts, text.length, offset),
+        end: positionAt(starts, text.length, endOffset),
+    };
+}
+function inspectDepthBeforeParsing(text) {
+    const scanner = createScanner(text, false);
+    let depth = 0;
+    let maximumDepth = 0;
+    let firstTooDeepOffset;
+    for (let token = scanner.scan(); token !== END_OF_FILE_TOKEN; token = scanner.scan()) {
+        if (token === OPEN_BRACE_TOKEN
+            || token === OPEN_BRACKET_TOKEN) {
+            depth += 1;
+            maximumDepth = Math.max(maximumDepth, depth);
+            if (depth > SCHEMA_TEXT_MAX_DEPTH && firstTooDeepOffset === undefined) {
+                firstTooDeepOffset = scanner.getTokenOffset();
+            }
+        }
+        else if (token === CLOSE_BRACE_TOKEN
+            || token === CLOSE_BRACKET_TOKEN) {
+            depth = Math.max(0, depth - 1);
+        }
+    }
+    return { maximumDepth, firstTooDeepOffset };
+}
+function nodeRange(text, starts, node, anchorOnly = false) {
+    return sourceRange(text, starts, node.offset, anchorOnly ? 1 : node.length);
+}
+function inspectStructure(text, starts, root) {
+    const duplicates = [];
+    let maximumDepth = 0;
+    let firstTooDeep;
+    const pending = [{
+            node: root,
+            path: [],
+            depth: 0,
+        }];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const { node, path } = current;
+        const container = node.type === 'object' || node.type === 'array';
+        const depth = container ? current.depth + 1 : current.depth;
+        if (container && depth > maximumDepth)
+            maximumDepth = depth;
+        if (container && depth > SCHEMA_TEXT_MAX_DEPTH && !firstTooDeep) {
+            firstTooDeep = node;
+        }
+        if (node.type === 'object') {
+            const seen = new Set();
+            const children = node.children ?? [];
+            const nested = [];
+            for (const property of children) {
+                const keyNode = property.children?.[0];
+                const valueNode = property.children?.[1];
+                if (!keyNode || typeof keyNode.value !== 'string')
+                    continue;
+                const key = keyNode.value;
+                const propertyPath = [...path, key];
+                if (seen.has(key)
+                    && duplicates.length <= SCHEMA_TEXT_MAX_ERRORS) {
+                    duplicates.push({
+                        code: 'JSON_DUPLICATE_PROPERTY',
+                        path: toJsonPointer(propertyPath),
+                        message: `Duplicate property "${key}"`,
+                        params: { property: key },
+                        range: nodeRange(text, starts, keyNode),
+                    });
+                }
+                else {
+                    seen.add(key);
+                }
+                if (valueNode)
+                    nested.push({ node: valueNode, path: propertyPath, depth });
+            }
+            for (let index = nested.length - 1; index >= 0; index -= 1) {
+                pending.push(nested[index]);
+            }
+        }
+        else if (node.type === 'array') {
+            const children = node.children ?? [];
+            for (let index = children.length - 1; index >= 0; index -= 1) {
+                pending.push({ node: children[index], path: [...path, index], depth });
+            }
+        }
+    }
+    duplicates.sort((left, right) => left.range.start.offset - right.range.start.offset);
+    return { duplicates, maximumDepth, firstTooDeep };
+}
+function syntaxIssues(text, starts, parseErrors) {
+    return parseErrors
+        .slice(0, SCHEMA_TEXT_MAX_ERRORS + 1)
+        .map(error => ({
+        code: 'JSON_SYNTAX_ERROR',
+        path: toJsonPointer(getLocation(text, error.offset).path),
+        message: `Invalid JSON: ${printParseErrorCode(error.error)}`,
+        params: { parseError: printParseErrorCode(error.error) },
+        range: sourceRange(text, starts, error.offset, error.length),
+    }));
+}
+function findSemanticNode(root, issue) {
+    const exactPath = pointerSegments(issue.path);
+    const exact = resolvePointerNode(root, exactPath);
+    if (exact)
+        return { node: exact, anchorOnly: false };
+    if (issue.anchorPath !== undefined) {
+        const anchor = resolvePointerNode(root, pointerSegments(issue.anchorPath));
+        if (anchor)
+            return { node: anchor, anchorOnly: true };
+    }
+    for (let length = exactPath.length - 1; length >= 0; length -= 1) {
+        const ancestor = resolvePointerNode(root, exactPath.slice(0, length));
+        if (ancestor)
+            return { node: ancestor, anchorOnly: true };
+    }
+    return { node: root, anchorOnly: true };
+}
+function locateSemanticIssue(text, starts, root, issue) {
+    const location = findSemanticNode(root, issue);
+    return {
+        ...issue,
+        range: nodeRange(text, starts, location.node, location.anchorOnly),
+    };
+}
+function invalidResult(errors) {
+    return {
+        valid: false,
+        errors: errors.slice(0, SCHEMA_TEXT_MAX_ERRORS),
+        truncated: errors.length > SCHEMA_TEXT_MAX_ERRORS,
+    };
+}
+/** Parse strict JSON and return syntax plus SDK-owned schema diagnostics. */
+function validateSchemaText(text) {
+    if (text.length > SCHEMA_TEXT_MAX_CHARACTERS) {
+        const starts = lineStarts(text, SCHEMA_TEXT_MAX_CHARACTERS + 1);
+        return invalidResult([{
+                code: 'JSON_INPUT_TOO_LARGE',
+                path: '',
+                message: `JSON input exceeds ${SCHEMA_TEXT_MAX_CHARACTERS} characters`,
+                params: { actual: text.length, limit: SCHEMA_TEXT_MAX_CHARACTERS },
+                range: sourceRange(text, starts, SCHEMA_TEXT_MAX_CHARACTERS, 1),
+            }]);
+    }
+    const starts = lineStarts(text);
+    // jsonc-parser builds nested nodes recursively. Scan tokens first so even
+    // malformed, unclosed input cannot exhaust the parser stack.
+    const depthInspection = inspectDepthBeforeParsing(text);
+    if (depthInspection.firstTooDeepOffset !== undefined) {
+        return invalidResult([{
+                code: 'JSON_MAX_DEPTH_EXCEEDED',
+                path: '',
+                message: `JSON nesting exceeds ${SCHEMA_TEXT_MAX_DEPTH} levels`,
+                params: {
+                    actual: depthInspection.maximumDepth,
+                    limit: SCHEMA_TEXT_MAX_DEPTH,
+                },
+                range: sourceRange(text, starts, depthInspection.firstTooDeepOffset, 1),
+            }]);
+    }
+    const parseErrors = [];
+    const root = parseTree(text, parseErrors, {
+        allowEmptyContent: false,
+        allowTrailingComma: false,
+        disallowComments: true,
+    });
+    if (parseErrors.length > 0 || !root) {
+        const errors = syntaxIssues(text, starts, parseErrors);
+        if (errors.length === 0) {
+            errors.push({
+                code: 'JSON_SYNTAX_ERROR',
+                path: '',
+                message: 'Invalid JSON: ValueExpected',
+                params: { parseError: 'ValueExpected' },
+                range: sourceRange(text, starts, 0, 0),
+            });
+        }
+        return invalidResult(errors);
+    }
+    const inspection = inspectStructure(text, starts, root);
+    const structuralIssues = [...inspection.duplicates];
+    if (inspection.firstTooDeep) {
+        structuralIssues.push({
+            code: 'JSON_MAX_DEPTH_EXCEEDED',
+            path: toJsonPointer(getLocation(text, inspection.firstTooDeep.offset).path),
+            message: `JSON nesting exceeds ${SCHEMA_TEXT_MAX_DEPTH} levels`,
+            params: {
+                actual: inspection.maximumDepth,
+                limit: SCHEMA_TEXT_MAX_DEPTH,
+            },
+            range: nodeRange(text, starts, inspection.firstTooDeep, true),
+        });
+    }
+    if (structuralIssues.length > 0) {
+        structuralIssues.sort((left, right) => left.range.start.offset - right.range.start.offset);
+        return invalidResult(structuralIssues);
+    }
+    const schema = getNodeValue(root);
+    const semanticIssues = validateSchemaDetailed(schema)
+        .slice(0, SCHEMA_TEXT_MAX_ERRORS + 1)
+        .map(issue => locateSemanticIssue(text, starts, root, issue));
+    if (semanticIssues.length > 0)
+        return invalidResult(semanticIssues);
+    return { valid: true, schema, errors: [] };
+}
+
+export { SCHEMA_TEXT_MAX_CHARACTERS, SCHEMA_TEXT_MAX_DEPTH, SCHEMA_TEXT_MAX_ERRORS, validateSchemaText };