@altopelago/aeos-core 0.12.0 → 0.13.0

package/dist/validate.js

@@ -14,7 +14,9 @@ import { checkReferenceForms } from './rules/referenceForm.js';
 import { checkNumericForm } from './rules/numericForm.js';
 import { checkStringForm, checkPatterns, matchesPortablePattern } from './rules/stringForm.js';
 import { datatypeBase, declaredRadixFromDatatype, parseClarifierValues } from './util/datatypes.js';
+import { compareNumericValues } from './util/numericBounds.js';
 import { parseAddress, resolveAddress, } from '@altopelago/sansa';
+import { formatDatatypeDescriptor, } from '@altopelago/aeon-aes';
 const TYPE_ALIASES = {
     NumberLiteral: ['NumberLiteral'],
     StringLiteral: ['StringLiteral'],
@@ -39,6 +41,7 @@ const TYPE_ALIASES = {
     CloneReference: ['CloneReference'],
     PointerReference: ['PointerReference'],
     NodeLiteral: ['NodeLiteral'],
+    NodeHead: ['NodeHead'],
 };
 function formatQuotedMemberSegment(key) {
     return `.[${JSON.stringify(String(key))}]`;
@@ -207,6 +210,8 @@ export function validate(aes, schema, options = {}) {
     // Phase 3: (moved to run after Phase 2)
     // Helpers: format canonical path (local, no runtime AEON deps)
     function formatCanonicalPath(path) {
+        if (typeof path === 'string')
+            return path;
         if (!path || !Array.isArray(path.segments))
             return '$';
         let result = '';
@@ -235,6 +240,10 @@ export function validate(aes, schema, options = {}) {
     function toTuple(span) {
         if (!span)
             return null;
+        if (typeof span === 'string') {
+            const match = span.match(/^(0|[1-9][0-9]*):(0|[1-9][0-9]*)$/u);
+            return match === null ? null : [Number(match[1]), Number(match[2])];
+        }
         if (Array.isArray(span) && span.length === 2 && typeof span[0] === 'number')
             return span;
         if (span.start && span.end && typeof span.start.offset === 'number')
@@ -264,6 +273,7 @@ export function validate(aes, schema, options = {}) {
             const element = elements[i];
             const attributes = buildAttributeInfoMap(element?.attributes);
             const info = {
+                ...(typeof element?.structuralId === 'string' ? { identity: element.structuralId } : {}),
                 type: typeof element?.type === 'string' ? element.type : 'Unknown',
                 raw: typeof element?.raw === 'string' ? element.raw : '',
                 value: typeof element?.value === 'string' ? element.value : '',
@@ -288,6 +298,7 @@ export function validate(aes, schema, options = {}) {
             const valueNode = entry?.value;
             const nestedAttributes = buildAttributeInfoMap(entry?.annotations);
             const info = {
+                ...(typeof entry?.structuralId === 'string' ? { identity: entry.structuralId } : {}),
                 type: typeof valueNode?.type === 'string' ? valueNode.type : 'Unknown',
                 raw: typeof valueNode?.raw === 'string' ? valueNode.raw : '',
                 value: typeof valueNode?.value === 'string' ? valueNode.value : '',
@@ -305,6 +316,7 @@ export function validate(aes, schema, options = {}) {
         for (const [key, attribute] of attributes.entries()) {
             const attributePath = appendAttributePath(basePath, key);
             eventsByPath.set(attributePath, {
+                ...(attribute.identity !== undefined ? { identity: attribute.identity } : {}),
                 type: attribute.type,
                 raw: attribute.raw,
                 value: attribute.value,
@@ -318,6 +330,7 @@ export function validate(aes, schema, options = {}) {
     for (let i = 0; i < aes.length; i++) {
         const event = aes[i];
         const pathStr = formatCanonicalPath(event.path);
+        const portable = isPortableTelexRecord(event);
         if (pathStr.length > resourcePolicy.max_path_length) {
             emitResourceError(ctx, pathStr, `Path length ${pathStr.length} exceeds max_path_length ${resourcePolicy.max_path_length}`, toTuple(event.span));
         }
@@ -341,9 +354,27 @@ export function validate(aes, schema, options = {}) {
         else {
             seen.set(pathStr, event.span);
             // Collect event info for Phase 5-7 checks
-            if (event.value && typeof event.value.type === 'string') {
+            if (portable) {
+                const value = typeof event.value === 'string' ? event.value : '';
+                const datatype = portableDatatype(event);
+                const info = {
+                    ...(typeof event.identity === 'string' ? { identity: event.identity } : {}),
+                    type: event.kind,
+                    raw: value,
+                    value,
+                    ...(datatype !== undefined ? { datatype } : {}),
+                    span: toTuple(event.span),
+                    ...((event.kind === 'CloneReference' || event.kind === 'PointerReference')
+                        && typeof event.value === 'string'
+                        ? { referencePath: parsePortableReferencePath(event.value) }
+                        : {}),
+                };
+                eventsByPath.set(pathStr, info);
+            }
+            else if (event.value && typeof event.value.type === 'string') {
                 const attributes = buildAttributeInfoMap(event.annotations);
                 const info = {
+                    ...(typeof event.structuralId === 'string' ? { identity: event.structuralId } : {}),
                     type: event.value.type,
                     raw: typeof event.value.raw === 'string' ? event.value.raw : '',
                     value: typeof event.value.value === 'string' ? event.value.value : '',
@@ -379,18 +410,26 @@ export function validate(aes, schema, options = {}) {
         }
         // Register index even for first occurrence
     }
+    hydratePortableAttributes(eventsByPath, aes);
+    hydratePortableContainerArities(aes, containerArity, resourcePolicy, ctx, toTuple);
     for (const [path, info] of eventsByPath) {
         enforceStringLengthResourceBudget(info, path, resourcePolicy, ctx);
     }
     // Optional separator literal trailing-delimiter policy
     if (trailingSeparatorPolicy !== 'off') {
         for (const event of aes) {
-            if (event?.value?.type !== 'SeparatorLiteral')
+            const portable = isPortableTelexRecord(event);
+            const kind = portable ? event.kind : event?.value?.type;
+            if (kind !== 'SeparatorLiteral')
                 continue;
-            const payload = typeof event.value.value === 'string' ? event.value.value : '';
+            const payload = portable
+                ? (typeof event.value === 'string' ? event.value : '')
+                : (typeof event.value.value === 'string' ? event.value.value : '');
             if (payload.length === 0)
                 continue;
-            const separators = decodeSeparatorChars(typeof event.datatype === 'string' ? event.datatype : undefined);
+            const separators = decodeSeparatorChars(portable
+                ? portableDatatype(event)
+                : (typeof event.datatype === 'string' ? event.datatype : undefined));
             if (separators.length === 0)
                 continue;
             const lastChar = payload[payload.length - 1];
@@ -405,7 +444,11 @@ export function validate(aes, schema, options = {}) {
         }
     }
     // Phase 3: Build rule index from schema (run after baseline invariants)
+    const errorCountBeforeSchemaIndex = ctx.errors.length;
     const ruleIndex = buildRuleIndex(schema, ctx);
+    if (ctx.errors.length > errorCountBeforeSchemaIndex) {
+        return createFailingEnvelope(ctx.errors, ctx.warnings, {});
+    }
     const selectorExpansionBudget = { count: 0 };
     const expandedRuleIndex = expandSelectorRules(ruleIndex, schema, eventsByPath, ctx, resourcePolicy, selectorExpansionBudget);
     const effectiveRuleIndex = mergeDatatypeRules(expandedRuleIndex, schema.datatype_rules, eventsByPath);
@@ -528,7 +571,7 @@ function checkWorldPolicy(schema, aes, boundPaths, eventsByPath, ctx) {
     }
     for (const event of aes) {
         const key = typeof event.key === 'string' ? event.key : '';
-        if (key.startsWith('aeon:'))
+        if (event.sourcePlane === 'header' || (event.sourcePlane === undefined && key.startsWith('aeon:')))
             continue;
         const path = formatCanonicalPathLocal(event.path);
         if (!boundPaths.has(path))
@@ -664,6 +707,15 @@ function constraintBranchMatchesEvent(constraints, event) {
             return false;
         if (event.type === 'RadixLiteral' && constraints.radix !== undefined && !radixConstraintMatches(event.datatype, event.raw, constraints))
             return false;
+        if (constraints.min_value !== undefined || constraints.max_value !== undefined) {
+            const normalized = normalizeRangeLiteral(event.type, event.raw);
+            if (normalized === null)
+                return false;
+            if (constraints.min_value !== undefined && compareNumericValues(normalized, constraints.min_value) === -1)
+                return false;
+            if (constraints.max_value !== undefined && compareNumericValues(normalized, constraints.max_value) === 1)
+                return false;
+        }
     }
     return true;
 }
@@ -770,6 +822,8 @@ function insertAeosSansaResolvePath(root, path, info) {
         }
     }
     current.info = info;
+    if (info.identity !== undefined)
+        current.identity = info.identity;
 }
 function getOrCreateChildBinding(parent, path, identity) {
     const existing = parent.children.find((child) => identity.name !== undefined
@@ -865,17 +919,17 @@ function checkDatatypeRules(datatypeRules, eventsByPath, ctx) {
             continue;
         }
         if (constraints.min_value !== undefined || constraints.max_value !== undefined) {
-            const range = normalizeRangeLiteral(event.type, raw);
-            if (!range) {
+            const normalized = normalizeRangeLiteral(event.type, raw);
+            if (!normalized) {
                 emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': range constraints require numeric literal form`, ErrorCodes.NUMERIC_FORM_VIOLATION));
                 continue;
             }
-            if (constraints.min_value !== undefined && isBelowRange(range, constraints.min_value)) {
-                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': expected value >= ${constraints.min_value}, got ${range.raw}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            if (constraints.min_value !== undefined && compareNumericValues(normalized, constraints.min_value) === -1) {
+                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': expected value >= ${constraints.min_value}, got ${normalized}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
                 continue;
             }
-            if (constraints.max_value !== undefined && isAboveRange(range, constraints.max_value)) {
-                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': expected value <= ${constraints.max_value}, got ${range.raw}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            if (constraints.max_value !== undefined && compareNumericValues(normalized, constraints.max_value) === 1) {
+                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': expected value <= ${constraints.max_value}, got ${normalized}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
             }
         }
     }
@@ -987,6 +1041,21 @@ function validateAttributeEntry(path, entry, constraints, datatypeRules, ctx) {
                 emitError(ctx, createDiag(path, entry.span, `Numeric form violation: radix literal digit '${invalidDigit}' is outside radix ${effectiveConstraints.radix}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
             }
         }
+        if (effectiveConstraints.min_value !== undefined || effectiveConstraints.max_value !== undefined) {
+            const normalized = normalizeRangeLiteral(entry.type, entry.raw);
+            if (normalized === null) {
+                emitError(ctx, createDiag(path, entry.span, 'Numeric form violation: range constraints require numeric literal form', ErrorCodes.NUMERIC_FORM_VIOLATION));
+                return;
+            }
+            if (effectiveConstraints.min_value !== undefined
+                && compareNumericValues(normalized, effectiveConstraints.min_value) === -1) {
+                emitError(ctx, createDiag(path, entry.span, `Numeric form violation: expected value >= ${effectiveConstraints.min_value}, got ${normalized}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            }
+            if (effectiveConstraints.max_value !== undefined
+                && compareNumericValues(normalized, effectiveConstraints.max_value) === 1) {
+                emitError(ctx, createDiag(path, entry.span, `Numeric form violation: expected value <= ${effectiveConstraints.max_value}, got ${normalized}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            }
+        }
     }
     if (isStringType(entry.type)) {
         if (effectiveConstraints.min_length !== undefined && entry.value.length < effectiveConstraints.min_length) {
@@ -1092,36 +1161,20 @@ function datatypeTypeMatches(actualType, expectedType, raw) {
 }
 function normalizeRangeLiteral(type, raw) {
     const normalized = raw.replace(/_/g, '');
-    if (type === 'FloatLiteral' || /[.eE]/.test(normalized)) {
-        if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(normalized))
-            return null;
-        const value = Number(normalized);
-        return Number.isFinite(value) ? { kind: 'float', raw: normalized, value } : null;
-    }
-    if (!/^[+-]?\d+$/.test(normalized))
+    if (type !== 'FloatLiteral' && type !== 'NumberLiteral' && type !== 'IntegerLiteral')
         return null;
-    return { kind: 'integer', raw: normalized, value: BigInt(normalized) };
-}
-function isBelowRange(range, bound) {
-    if (range.kind === 'integer' && /^[-+]?\d+$/.test(bound)) {
-        return range.value < BigInt(bound);
-    }
-    return rangeAsNumber(range) < Number(bound);
-}
-function isAboveRange(range, bound) {
-    if (range.kind === 'integer' && /^[-+]?\d+$/.test(bound)) {
-        return range.value > BigInt(bound);
-    }
-    return rangeAsNumber(range) > Number(bound);
-}
-function rangeAsNumber(range) {
-    return range.kind === 'integer' ? Number(range.value) : range.value;
+    return compareNumericValues(normalized, normalized) === null ? null : normalized;
 }
 function countIntegerDigits(raw) {
     return raw.replace(/^[+-]/, '').replace(/_/g, '').split('.')[0]?.length ?? 0;
 }
 function hasDigitFormConstraints(constraints) {
-    return constraints.sign !== undefined || constraints.min_digits !== undefined || constraints.max_digits !== undefined || constraints.radix !== undefined;
+    return constraints.sign !== undefined
+        || constraints.min_digits !== undefined
+        || constraints.max_digits !== undefined
+        || constraints.radix !== undefined
+        || constraints.min_value !== undefined
+        || constraints.max_value !== undefined;
 }
 function isDigitFormLiteral(type) {
     return type === 'NumberLiteral' || type === 'HexLiteral' || type === 'RadixLiteral';
@@ -1191,7 +1244,159 @@ function isNegative(raw) {
 function isFormNegative(raw) {
     return /^[$#%^]?-/.test(raw) || raw.startsWith('-');
 }
+function isPortableTelexRecord(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const record = value;
+    return typeof record.path === 'string' && typeof record.kind === 'string' && record.header === undefined;
+}
+function portableDatatype(record) {
+    if (typeof record.datatype !== 'string')
+        return undefined;
+    if (!Array.isArray(record.generics) || !Array.isArray(record.clarifiers))
+        return record.datatype;
+    return formatDatatypeDescriptor({
+        datatype: record.datatype,
+        generics: record.generics,
+        clarifiers: record.clarifiers,
+    });
+}
+function parsePortablePath(path) {
+    if (!path.startsWith('$'))
+        throw new TypeError(`Expected absolute portable AES path: ${path}`);
+    const segments = [];
+    const prefixes = [];
+    let cursor = 1;
+    while (cursor < path.length) {
+        const start = cursor;
+        let type;
+        if (path.startsWith('.@.', cursor)) {
+            type = 'attribute';
+            cursor += 3;
+        }
+        else if (path[cursor] === '.') {
+            type = 'member';
+            cursor += 1;
+        }
+        else if (path[cursor] === '[') {
+            const match = path.slice(cursor).match(/^\[(0|[1-9][0-9]*)\]/u);
+            if (match === null)
+                throw new TypeError(`Invalid portable AES index: ${path}`);
+            cursor += match[0].length;
+            segments.push({ type: 'index', index: Number(match[1]) });
+            prefixes.push(path.slice(0, cursor));
+            continue;
+        }
+        else {
+            throw new TypeError(`Invalid portable AES path: ${path}`);
+        }
+        let key;
+        if (path[cursor] === '[' && path[cursor + 1] === '"') {
+            let end = cursor + 2;
+            let escaped = false;
+            for (; end < path.length; end += 1) {
+                const character = path[end];
+                if (escaped)
+                    escaped = false;
+                else if (character === '\\')
+                    escaped = true;
+                else if (character === '"')
+                    break;
+            }
+            if (path[end] !== '"' || path[end + 1] !== ']')
+                throw new TypeError(`Invalid quoted member: ${path}`);
+            key = JSON.parse(path.slice(cursor + 1, end + 1));
+            cursor = end + 2;
+        }
+        else {
+            const match = path.slice(cursor).match(/^[A-Za-z_][A-Za-z0-9_]*/u);
+            if (match === null)
+                throw new TypeError(`Invalid portable AES member: ${path}`);
+            key = match[0];
+            cursor += key.length;
+        }
+        segments.push({ type, key });
+        prefixes.push(path.slice(0, cursor));
+        if (cursor === start)
+            throw new TypeError(`Invalid portable AES path: ${path}`);
+    }
+    return { segments, prefixes };
+}
+function parsePortableReferencePath(path) {
+    return parsePortablePath(path).segments.map((segment) => {
+        if (segment.type === 'index')
+            return segment.index;
+        if (segment.type === 'attribute')
+            return { type: 'attr', key: segment.key };
+        return segment.key;
+    });
+}
+function hydratePortableAttributes(eventsByPath, aes) {
+    const attributes = aes
+        .filter(isPortableTelexRecord)
+        .map((record) => {
+        try {
+            return { record, details: parsePortablePath(record.path) };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => entry !== null)
+        .filter(({ details }) => details.segments.at(-1)?.type === 'attribute')
+        .sort((a, b) => a.details.segments.length - b.details.segments.length);
+    for (const { record, details } of attributes) {
+        const final = details.segments.at(-1);
+        if (final?.type !== 'attribute')
+            continue;
+        const ownerPath = details.prefixes.at(-2) ?? '$';
+        const owner = eventsByPath.get(ownerPath);
+        const attribute = eventsByPath.get(record.path);
+        if (owner === undefined || attribute === undefined)
+            continue;
+        const mapped = new Map(owner.attributes ?? []);
+        mapped.set(final.key, attribute);
+        owner.attributes = mapped;
+    }
+}
+function hydratePortableContainerArities(aes, containerArity, resourcePolicy, ctx, toTuple) {
+    const records = aes.filter(isPortableTelexRecord);
+    if (records.length === 0)
+        return;
+    const details = new Map();
+    for (const record of records) {
+        try {
+            details.set(record.path, parsePortablePath(record.path));
+        }
+        catch {
+            // The portable AES validation layer reports malformed paths.
+        }
+    }
+    for (const record of records) {
+        if (!['ObjectNode', 'ListNode', 'TupleLiteral', 'NodeLiteral', 'NodeHead'].includes(record.kind))
+            continue;
+        const childOwner = record.kind === 'NodeLiteral' ? `${record.path}[0]` : record.path;
+        let count = 0;
+        for (const candidate of records) {
+            const candidateDetails = details.get(candidate.path);
+            if (candidateDetails === undefined)
+                continue;
+            const parent = candidateDetails.prefixes.at(-2) ?? '$';
+            const last = candidateDetails.segments.at(-1);
+            if (parent !== childOwner || last === undefined)
+                continue;
+            if (record.kind === 'ObjectNode' ? last.type === 'member' : last.type === 'index')
+                count += 1;
+        }
+        containerArity.set(record.path, count);
+        if (count > resourcePolicy.max_container_children_default) {
+            emitResourceError(ctx, record.path, `Container child count ${count} exceeds max_container_children_default ${resourcePolicy.max_container_children_default}`, toTuple(record.span));
+        }
+    }
+}
 function formatCanonicalPathLocal(path) {
+    if (typeof path === 'string')
+        return path;
     if (!path || !Array.isArray(path.segments))
         return '$';
     let result = '';
@@ -1220,6 +1425,10 @@ function formatCanonicalPathLocal(path) {
 function toTupleLocal(span) {
     if (!span)
         return null;
+    if (typeof span === 'string') {
+        const match = span.match(/^(0|[1-9][0-9]*):(0|[1-9][0-9]*)$/u);
+        return match === null ? null : [Number(match[1]), Number(match[2])];
+    }
     if (Array.isArray(span) && span.length === 2 && typeof span[0] === 'number')
         return span;
     if (span.start && span.end && typeof span.start.offset === 'number')