@altopelago/aeos-core 0.9.0 → 0.9.2

package/dist/validate.js

@@ -12,7 +12,7 @@ import { checkPresence } from './rules/presence.js';
 import { checkTypes } from './rules/typeCheck.js';
 import { checkReferenceForms } from './rules/referenceForm.js';
 import { checkNumericForm } from './rules/numericForm.js';
-import { checkStringForm, checkPatterns } from './rules/stringForm.js';
+import { checkStringForm, checkPatterns, matchesPortablePattern } from './rules/stringForm.js';
 const TYPE_ALIASES = {
     NumberLiteral: ['NumberLiteral'],
     StringLiteral: ['StringLiteral'],
@@ -22,6 +22,17 @@ const TYPE_ALIASES = {
     ListNode: ['ListNode'],
     ListLiteral: ['ListNode', 'ListLiteral'],
     TupleLiteral: ['TupleLiteral'],
+    ToggleLiteral: ['ToggleLiteral'],
+    InfinityLiteral: ['InfinityLiteral'],
+    NaNLiteral: ['NaNLiteral'],
+    HexLiteral: ['HexLiteral'],
+    RadixLiteral: ['RadixLiteral'],
+    EncodingLiteral: ['EncodingLiteral'],
+    SeparatorLiteral: ['SeparatorLiteral'],
+    DateLiteral: ['DateLiteral'],
+    TimeLiteral: ['TimeLiteral'],
+    DateTimeLiteral: ['DateTimeLiteral'],
+    ZRUTDateTimeLiteral: ['ZRUTDateTimeLiteral'],
     CloneReference: ['CloneReference'],
     PointerReference: ['PointerReference'],
     NodeLiteral: ['NodeLiteral'],
@@ -29,6 +40,113 @@ const TYPE_ALIASES = {
 function formatQuotedMemberSegment(key) {
     return `.[${JSON.stringify(String(key))}]`;
 }
+const DEFAULT_RESOURCE_POLICY = {
+    max_events: 100_000,
+    max_rules: 10_000,
+    max_any_of_cases: 64,
+    max_schema_depth: 64,
+    max_path_length: 4_096,
+    max_reference_resolution_steps: 64,
+    max_selector_expansions: 100_000,
+    max_string_length_default: 10_000_000,
+    max_container_children_default: 1_000_000,
+};
+function normalizeResourcePolicy(policy, source, ctx) {
+    if (policy === undefined)
+        return {};
+    if (policy === null || typeof policy !== 'object') {
+        emitResourceError(ctx, '$', `${source} resource policy must be an object`);
+        return {};
+    }
+    const normalized = {};
+    for (const key of Object.keys(policy)) {
+        if (!(key in DEFAULT_RESOURCE_POLICY)) {
+            emitResourceError(ctx, '$', `Unknown ${source} resource policy key: ${String(key)}`);
+            continue;
+        }
+        const value = policy[key];
+        if (value !== undefined && (typeof value !== 'number' || !Number.isInteger(value) || value < 0)) {
+            emitResourceError(ctx, '$', `${source} resource policy ${String(key)} must be a non-negative integer`);
+            continue;
+        }
+        if (value !== undefined) {
+            normalized[key] = value;
+        }
+    }
+    return normalized;
+}
+function resolveResourcePolicy(schemaPolicy, optionPolicy, ctx) {
+    return {
+        ...DEFAULT_RESOURCE_POLICY,
+        ...normalizeResourcePolicy(schemaPolicy, 'schema', ctx),
+        ...normalizeResourcePolicy(optionPolicy, 'option', ctx),
+    };
+}
+function emitResourceError(ctx, path, message, span = null) {
+    emitError(ctx, createDiag(path, span, message, ErrorCodes.INVALID_SCHEMA_POLICY));
+}
+const STRING_LIKE_VALUE_TYPES = new Set([
+    'StringLiteral',
+    'TrimtickLiteral',
+    'SeparatorLiteral',
+    'HexLiteral',
+    'EncodingLiteral',
+    'NullLiteral',
+    'DateLiteral',
+    'TimeLiteral',
+    'DateTimeLiteral',
+    'ZRUTDateTimeLiteral',
+]);
+function stringLikePayloadLength(event) {
+    if (!STRING_LIKE_VALUE_TYPES.has(event.type))
+        return null;
+    const payload = event.value.length > 0 ? event.value : event.raw;
+    return payload.length;
+}
+function enforceStringLengthResourceBudget(info, path, policy, ctx) {
+    const payloadLength = stringLikePayloadLength(info);
+    if (payloadLength !== null && payloadLength > policy.max_string_length_default) {
+        emitResourceError(ctx, path, `String-like payload length ${payloadLength} exceeds max_string_length_default ${policy.max_string_length_default}`, info.span);
+    }
+    for (const [key, attribute] of info.attributes ?? []) {
+        enforceStringLengthResourceBudget(attribute, `${path}@${key}`, policy, ctx);
+    }
+}
+function inspectSchemaResourceShape(schema, policy, ctx) {
+    for (const rule of schema.rules) {
+        const rulePath = typeof rule.path === 'string' && rule.path.length > 0
+            ? rule.path
+            : typeof rule.selector === 'string' && rule.selector.length > 0
+                ? rule.selector
+                : '$';
+        if (rulePath.length > policy.max_path_length) {
+            emitResourceError(ctx, rulePath, `Rule path length ${rulePath.length} exceeds max_path_length ${policy.max_path_length}`);
+        }
+        inspectConstraintResourceShape(rule.constraints, rulePath, 1, policy, ctx);
+    }
+    for (const [datatype, constraints] of Object.entries(schema.datatype_rules ?? {})) {
+        inspectConstraintResourceShape(constraints, `datatype_rules.${datatype}`, 1, policy, ctx);
+    }
+}
+function inspectConstraintResourceShape(constraints, path, depth, policy, ctx) {
+    if (depth > policy.max_schema_depth) {
+        emitResourceError(ctx, path, `Schema constraint depth exceeds max_schema_depth ${policy.max_schema_depth}`);
+        return;
+    }
+    if (constraints.any_of !== undefined) {
+        if (constraints.any_of.length > policy.max_any_of_cases) {
+            emitResourceError(ctx, path, `any_of case count ${constraints.any_of.length} exceeds max_any_of_cases ${policy.max_any_of_cases}`);
+        }
+        constraints.any_of.forEach((branch, index) => {
+            inspectConstraintResourceShape(branch, `${path}.any_of[${index}]`, depth + 1, policy, ctx);
+        });
+    }
+    if (constraints.attributes !== undefined) {
+        for (const [key, child] of Object.entries(constraints.attributes)) {
+            inspectConstraintResourceShape(child, `${path}@${key}`, depth + 1, policy, ctx);
+        }
+    }
+}
 /**
  * Validate an AES against a schema.
  *
@@ -59,6 +177,20 @@ export function validate(aes, schema, options = {}) {
     // TODO: Phase 9 - Guarantees
     // Phase 1: Envelope plumbing
     const ctx = createDiagContext();
+    const resourcePolicy = resolveResourcePolicy(schema.resource_policy, options.resourcePolicy, ctx);
+    if (ctx.errors.length > 0) {
+        return createFailingEnvelope(ctx.errors, ctx.warnings, {});
+    }
+    if (aes.length > resourcePolicy.max_events) {
+        emitResourceError(ctx, '$', `AES event count ${aes.length} exceeds max_events ${resourcePolicy.max_events}`);
+    }
+    if (schema.rules.length > resourcePolicy.max_rules) {
+        emitResourceError(ctx, '$', `Schema rule count ${schema.rules.length} exceeds max_rules ${resourcePolicy.max_rules}`);
+    }
+    inspectSchemaResourceShape(schema, resourcePolicy, ctx);
+    if (ctx.errors.length > 0) {
+        return createFailingEnvelope(ctx.errors, ctx.warnings, {});
+    }
     // Phase 3: (moved to run after Phase 2)
     // Helpers: format canonical path (local, no runtime AEON deps)
     function formatCanonicalPath(path) {
@@ -171,6 +303,9 @@ export function validate(aes, schema, options = {}) {
     for (let i = 0; i < aes.length; i++) {
         const event = aes[i];
         const pathStr = formatCanonicalPath(event.path);
+        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));
+        }
         if (Array.isArray(event.path?.segments)) {
             for (const seg of event.path.segments) {
                 if (seg?.type === 'index') {
@@ -206,16 +341,31 @@ export function validate(aes, schema, options = {}) {
                 if ((event.value.type === 'TupleLiteral' || event.value.type === 'ListLiteral' || event.value.type === 'ListNode')
                     && Array.isArray(event.value.elements)) {
                     containerArity.set(pathStr, event.value.elements.length);
+                    if (event.value.elements.length > resourcePolicy.max_container_children_default) {
+                        emitResourceError(ctx, pathStr, `Container child count ${event.value.elements.length} exceeds max_container_children_default ${resourcePolicy.max_container_children_default}`, toTuple(event.span));
+                    }
                     hydrateIndexedFallback(pathStr, event.value, toTuple(event.span));
                 }
+                else if (event.value.type === 'ObjectNode' && Array.isArray(event.value.bindings)) {
+                    containerArity.set(pathStr, event.value.bindings.length);
+                    if (event.value.bindings.length > resourcePolicy.max_container_children_default) {
+                        emitResourceError(ctx, pathStr, `Container child count ${event.value.bindings.length} exceeds max_container_children_default ${resourcePolicy.max_container_children_default}`, toTuple(event.span));
+                    }
+                }
                 else if (event.value.type === 'NodeLiteral' && Array.isArray(event.value.children)) {
                     containerArity.set(pathStr, event.value.children.length);
+                    if (event.value.children.length > resourcePolicy.max_container_children_default) {
+                        emitResourceError(ctx, pathStr, `Container child count ${event.value.children.length} exceeds max_container_children_default ${resourcePolicy.max_container_children_default}`, toTuple(event.span));
+                    }
                     hydrateIndexedFallback(pathStr, event.value, toTuple(event.span));
                 }
             }
         }
         // Register index even for first occurrence
     }
+    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) {
@@ -240,33 +390,63 @@ export function validate(aes, schema, options = {}) {
     }
     // Phase 3: Build rule index from schema (run after baseline invariants)
     const ruleIndex = buildRuleIndex(schema, ctx);
+    const selectorExpansionBudget = { count: 0 };
+    const expandedRuleIndex = expandWildcardRules(expandSelectorRules(ruleIndex, schema, eventsByPath, ctx, resourcePolicy, selectorExpansionBudget), eventsByPath, ctx, resourcePolicy, selectorExpansionBudget);
+    const effectiveRuleIndex = mergeDatatypeRules(expandedRuleIndex, schema.datatype_rules, eventsByPath);
     // Phase 4: Presence checks (required fields)
     const boundPaths = new Set(seen.keys());
-    checkPresence(ruleIndex, boundPaths, ctx);
+    checkPresence(effectiveRuleIndex, boundPaths, ctx);
     checkWorldPolicy(schema, aes, boundPaths, ctx);
     // Phase 5: Type checks (literal kind)
-    checkReferenceForms(schema, ruleIndex, eventsByPath, ctx);
-    const effectiveEventsByPath = resolveReferenceFormEvents(ruleIndex, eventsByPath);
-    checkTypes(ruleIndex, effectiveEventsByPath, ctx);
-    // Phase 5b: core v1 arity checks for tuple/list containers
-    for (const [path, rule] of ruleIndex) {
-        const expectedLength = rule.constraints.length_exact;
-        if (expectedLength === undefined)
+    checkReferenceForms(schema, effectiveRuleIndex, eventsByPath, ctx);
+    const effectiveEventsByPath = resolveReferenceFormEvents(effectiveRuleIndex, eventsByPath, resourcePolicy, ctx);
+    const selectedRuleIndex = selectAnyOfRules(effectiveRuleIndex, effectiveEventsByPath, ctx);
+    checkTypes(selectedRuleIndex, effectiveEventsByPath, ctx);
+    // Phase 5b: core v1 arity/cardinality checks for tuple/list/node containers
+    for (const [path, rule] of selectedRuleIndex) {
+        const { length_exact, min_children, max_children } = rule.constraints;
+        if (length_exact === undefined && min_children === undefined && max_children === undefined)
             continue;
         const actualLength = containerArity.get(path);
         if (actualLength === undefined)
             continue;
-        if (typeof expectedLength === 'number' && actualLength !== expectedLength) {
+        const span = eventsByPath.get(path)?.span ?? null;
+        if (typeof length_exact === 'number' && actualLength !== length_exact) {
+            emitError(ctx, createDiag(path, span, `Container cardinality mismatch: expected exactly ${length_exact} children, got ${actualLength}`, ErrorCodes.TUPLE_ARITY_MISMATCH));
+        }
+        if (typeof min_children === 'number' && actualLength < min_children) {
+            emitError(ctx, createDiag(path, span, `Container cardinality mismatch: expected at least ${min_children} children, got ${actualLength}`, ErrorCodes.CONTAINER_CARDINALITY_MISMATCH));
+        }
+        if (typeof max_children === 'number' && actualLength > max_children) {
+            emitError(ctx, createDiag(path, span, `Container cardinality mismatch: expected at most ${max_children} children, got ${actualLength}`, ErrorCodes.CONTAINER_CARDINALITY_MISMATCH));
+        }
+    }
+    checkLexicalLiteralConstraints(selectedRuleIndex, effectiveEventsByPath, ctx);
+    // Phase 5c: constraints that widen NumberLiteral type acceptance to infinity/NaN
+    for (const [path, rule] of selectedRuleIndex) {
+        const event = effectiveEventsByPath.get(path);
+        if (!event)
+            continue;
+        if (event.type === 'InfinityLiteral' && rule.constraints.allow_infinity !== true) {
+            continue;
+        }
+        if (event.type === 'NaNLiteral' && rule.constraints.allow_nan !== true) {
+            continue;
+        }
+        if ((event.type === 'InfinityLiteral' || event.type === 'NaNLiteral')
+            && rule.constraints.type !== undefined
+            && !isNumericExpectedType(rule.constraints.type)) {
             const span = eventsByPath.get(path)?.span ?? null;
-            emitError(ctx, createDiag(path, span, `Tuple/List arity mismatch: expected ${expectedLength}, got ${actualLength}`, ErrorCodes.TUPLE_ARITY_MISMATCH));
+            emitError(ctx, createDiag(path, span, `Type mismatch: expected ${rule.constraints.type}, got ${event.type}`, ErrorCodes.TYPE_MISMATCH));
         }
     }
     // Phase 6: Numeric form constraints (sign, digit count)
-    checkNumericForm(ruleIndex, effectiveEventsByPath, ctx);
+    checkNumericForm(selectedRuleIndex, effectiveEventsByPath, ctx);
     // Phase 7: String form constraints (length, pattern)
-    checkStringForm(ruleIndex, effectiveEventsByPath, ctx);
-    checkPatterns(ruleIndex, effectiveEventsByPath, ctx);
-    checkAttributeConstraints(ruleIndex, effectiveEventsByPath, schema.datatype_rules, ctx);
+    checkStringForm(selectedRuleIndex, effectiveEventsByPath, ctx);
+    checkPatterns(selectedRuleIndex, effectiveEventsByPath, ctx);
+    checkAttributePolicy(schema, selectedRuleIndex, effectiveEventsByPath, ctx);
+    checkAttributeConstraints(selectedRuleIndex, effectiveEventsByPath, schema.datatype_rules, ctx);
     checkDatatypeRules(schema.datatype_rules, effectiveEventsByPath, ctx);
     if (ctx.errors.length > 0) {
         return createFailingEnvelope(ctx.errors, ctx.warnings, {});
@@ -317,7 +497,13 @@ export function validate(aes, schema, options = {}) {
 function checkWorldPolicy(schema, aes, boundPaths, ctx) {
     if ((schema.world ?? 'open') !== 'closed')
         return;
-    const allowedPaths = schema.rules.map((rule) => rule.path);
+    const allowedRules = schema.rules
+        .map((rule) => typeof rule.path === 'string' && rule.path.length > 0
+        ? { kind: 'path', value: rule.path }
+        : typeof rule.selector === 'string' && rule.selector.length > 0
+            ? { kind: 'selector', value: rule.selector }
+            : null)
+        .filter((rule) => rule !== null);
     for (const event of aes) {
         const key = typeof event.key === 'string' ? event.key : '';
         if (key.startsWith('aeon:'))
@@ -325,12 +511,14 @@ function checkWorldPolicy(schema, aes, boundPaths, ctx) {
         const path = formatCanonicalPathLocal(event.path);
         if (!boundPaths.has(path))
             continue;
-        if (allowedPaths.some((allowedPath) => matchesAllowedPath(path, allowedPath)))
+        if (allowedRules.some((rule) => rule.kind === 'selector'
+            ? matchesSelectorPath(path, rule.value)
+            : matchesAllowedPath(path, rule.value)))
             continue;
         emitError(ctx, createDiag(path, toTupleLocal(event.span), `Binding '${path}' is not allowed by closed-world schema`, ErrorCodes.UNEXPECTED_BINDING));
     }
 }
-function resolveReferenceFormEvents(ruleIndex, eventsByPath) {
+function resolveReferenceFormEvents(ruleIndex, eventsByPath, resourcePolicy, ctx) {
     const resolved = new Map(eventsByPath);
     for (const [path, rule] of ruleIndex.entries()) {
         if (rule.constraints.resolve_reference_form !== true)
@@ -338,8 +526,12 @@ function resolveReferenceFormEvents(ruleIndex, eventsByPath) {
         const event = eventsByPath.get(path);
         if (!event || !isReferenceType(event.type) || !event.referencePath)
             continue;
-        const terminal = resolveTerminalReferenceEvent(event, eventsByPath, new Set());
+        const resolutionState = { exhausted: false };
+        const terminal = resolveTerminalReferenceEvent(event, eventsByPath, new Set(), resourcePolicy.max_reference_resolution_steps, resolutionState);
         if (!terminal) {
+            if (resolutionState.exhausted) {
+                emitResourceError(ctx, path, `Reference resolution exceeded max_reference_resolution_steps ${resourcePolicy.max_reference_resolution_steps}`, event.span);
+            }
             resolved.delete(path);
             continue;
         }
@@ -350,10 +542,135 @@ function resolveReferenceFormEvents(ruleIndex, eventsByPath) {
     }
     return resolved;
 }
-function resolveTerminalReferenceEvent(event, eventsByPath, activePaths) {
+function expandSelectorRules(ruleIndex, schema, eventsByPath, ctx, resourcePolicy, expansionBudget) {
+    const expanded = new Map(ruleIndex);
+    for (const rule of schema.rules) {
+        if (typeof rule.selector !== 'string' || rule.selector.length === 0)
+            continue;
+        if (typeof rule.path === 'string' && rule.path.length > 0)
+            continue;
+        let matched = false;
+        for (const actualPath of eventsByPath.keys()) {
+            if (!matchesSelectorPath(actualPath, rule.selector))
+                continue;
+            matched = true;
+            expansionBudget.count += 1;
+            if (expansionBudget.count > resourcePolicy.max_selector_expansions) {
+                emitResourceError(ctx, rule.selector, `Selector expansion count exceeds max_selector_expansions ${resourcePolicy.max_selector_expansions}`);
+                return expanded;
+            }
+            if (!expanded.has(actualPath)) {
+                expanded.set(actualPath, { ...rule, path: actualPath });
+            }
+        }
+        if (!matched && rule.constraints.required === true) {
+            emitError(ctx, createDiag(rule.selector, null, `Missing required field: ${rule.selector}`, ErrorCodes.MISSING_REQUIRED_FIELD));
+        }
+    }
+    return expanded;
+}
+function expandWildcardRules(ruleIndex, eventsByPath, ctx, resourcePolicy, expansionBudget) {
+    const expanded = new Map(ruleIndex);
+    for (const [path, rule] of ruleIndex.entries()) {
+        if (!path.includes('[*]'))
+            continue;
+        expanded.delete(path);
+        for (const actualPath of eventsByPath.keys()) {
+            if (matchesAllowedPath(actualPath, path)) {
+                expansionBudget.count += 1;
+                if (expansionBudget.count > resourcePolicy.max_selector_expansions) {
+                    emitResourceError(ctx, path, `Wildcard expansion count exceeds max_selector_expansions ${resourcePolicy.max_selector_expansions}`);
+                    return expanded;
+                }
+                expanded.set(actualPath, { ...rule, path: actualPath });
+            }
+        }
+    }
+    return expanded;
+}
+function selectAnyOfRules(ruleIndex, eventsByPath, ctx) {
+    const selected = new Map(ruleIndex);
+    for (const [path, rule] of ruleIndex.entries()) {
+        if (!Array.isArray(rule.constraints.any_of))
+            continue;
+        const event = eventsByPath.get(path);
+        if (!event)
+            continue;
+        const outer = withoutAnyOf(rule.constraints);
+        const branch = rule.constraints.any_of.find((candidate) => constraintBranchMatchesEvent(candidate, event));
+        if (!branch) {
+            emitError(ctx, createDiag(path, event.span, `Value does not match any allowed constraint branch at ${path}`, ErrorCodes.TYPE_MISMATCH));
+            selected.set(path, { ...rule, constraints: outer });
+            continue;
+        }
+        selected.set(path, { ...rule, constraints: { ...outer, ...branch } });
+    }
+    return selected;
+}
+function withoutAnyOf(constraints) {
+    const { any_of: _anyOf, ...rest } = constraints;
+    return rest;
+}
+function patternMatches(pattern, value) {
+    return matchesPortablePattern(pattern, value);
+}
+function constraintBranchMatchesEvent(constraints, event) {
+    if (constraints.type_is !== undefined) {
+        const containerOk = constraints.type_is === 'list'
+            ? (event.type === 'ListLiteral' || event.type === 'ListNode')
+            : event.type === 'TupleLiteral';
+        if (!containerOk)
+            return false;
+    }
+    if (constraints.type !== undefined && !constraintTypeMatches(event.type, constraints.type, event.raw, constraints)) {
+        return false;
+    }
+    if (constraints.datatype !== undefined && event.datatype !== constraints.datatype) {
+        return false;
+    }
+    if (event.type === 'NullLiteral' && !nullValueMatches(event.value, constraints)) {
+        return false;
+    }
+    if (event.type === 'ToggleLiteral' && constraints.toggle_pair !== undefined && constraints.toggle_pair !== 'any') {
+        const value = (event.raw || event.value).toLowerCase();
+        const allowed = constraints.toggle_pair === 'yes_no'
+            ? ['yes', 'no']
+            : constraints.toggle_pair === 'on_off'
+                ? ['on', 'off']
+                : [];
+        if (allowed.length > 0 && !allowed.includes(value))
+            return false;
+    }
+    if (isStringType(event.type)) {
+        const valueLength = event.value.length;
+        if (constraints.min_length !== undefined && valueLength < constraints.min_length)
+            return false;
+        if (constraints.max_length !== undefined && valueLength > constraints.max_length)
+            return false;
+        if (!patternMatches(constraints.pattern, event.value))
+            return false;
+    }
+    if (hasDigitFormConstraints(constraints) && isDigitFormLiteral(event.type)) {
+        const digitCount = countFormDigits(event.type, event.raw);
+        if (constraints.sign === 'unsigned' && isFormNegative(event.raw))
+            return false;
+        if (constraints.min_digits !== undefined && digitCount < constraints.min_digits)
+            return false;
+        if (constraints.max_digits !== undefined && digitCount > constraints.max_digits)
+            return false;
+        if (event.type === 'RadixLiteral' && constraints.radix !== undefined && !radixConstraintMatches(event.datatype, event.raw, constraints))
+            return false;
+    }
+    return true;
+}
+function resolveTerminalReferenceEvent(event, eventsByPath, activePaths, remainingSteps, state) {
     if (!isReferenceType(event.type) || !event.referencePath) {
         return event;
     }
+    if (remainingSteps <= 0) {
+        state.exhausted = true;
+        return null;
+    }
     const targetPath = formatReferenceLookupPath(event.referencePath);
     if (activePaths.has(targetPath)) {
         return null;
@@ -364,7 +681,7 @@ function resolveTerminalReferenceEvent(event, eventsByPath, activePaths) {
     }
     activePaths.add(targetPath);
     const resolved = isReferenceType(target.type)
-        ? resolveTerminalReferenceEvent(target, eventsByPath, activePaths)
+        ? resolveTerminalReferenceEvent(target, eventsByPath, activePaths, remainingSteps - 1, state)
         : target;
     activePaths.delete(targetPath);
     return resolved;
@@ -404,6 +721,179 @@ function matchesAllowedPath(actualPath, allowedPath) {
     const pattern = `^${escaped}$`;
     return new RegExp(pattern).test(actualPath);
 }
+function tokenizeCanonicalLikePath(path) {
+    if (!path.startsWith('$'))
+        return null;
+    const segments = [];
+    let index = 1;
+    while (index < path.length) {
+        const marker = path[index];
+        if (marker === '.') {
+            index += 1;
+            if (path[index] === '[') {
+                const end = findBracketEnd(path, index);
+                if (end < 0)
+                    return null;
+                segments.push(path.slice(index, end + 1));
+                index = end + 1;
+                continue;
+            }
+            const start = index;
+            while (index < path.length && !['.', '[', '@'].includes(path[index])) {
+                index += 1;
+            }
+            if (start === index)
+                return null;
+            segments.push(path.slice(start, index));
+            continue;
+        }
+        if (marker === '[') {
+            const end = findBracketEnd(path, index);
+            if (end < 0)
+                return null;
+            segments.push(path.slice(index, end + 1));
+            index = end + 1;
+            continue;
+        }
+        if (marker === '@') {
+            index += 1;
+            if (path[index] === '[') {
+                const end = findBracketEnd(path, index);
+                if (end < 0)
+                    return null;
+                segments.push(`@${path.slice(index, end + 1)}`);
+                index = end + 1;
+                continue;
+            }
+            const start = index;
+            while (index < path.length && !['.', '[', '@'].includes(path[index])) {
+                index += 1;
+            }
+            if (start === index)
+                return null;
+            segments.push(`@${path.slice(start, index)}`);
+            continue;
+        }
+        return null;
+    }
+    return segments;
+}
+function findBracketEnd(path, start) {
+    let quote = null;
+    let escaped = false;
+    for (let index = start + 1; index < path.length; index++) {
+        const ch = path[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote) {
+            if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === ']')
+            return index;
+    }
+    return -1;
+}
+function matchesSelectorPath(actualPath, selector) {
+    if (actualPath === selector)
+        return true;
+    const actualSegments = tokenizeCanonicalLikePath(actualPath);
+    const selectorSegments = tokenizeCanonicalLikePath(selector);
+    if (!actualSegments || !selectorSegments)
+        return false;
+    const matchFrom = (actualIndex, selectorIndex) => {
+        if (selectorIndex === selectorSegments.length) {
+            return actualIndex === actualSegments.length;
+        }
+        const selectorSegment = selectorSegments[selectorIndex];
+        if (selectorSegment === '**') {
+            if (selectorIndex === selectorSegments.length - 1)
+                return true;
+            for (let nextActual = actualIndex; nextActual <= actualSegments.length; nextActual++) {
+                if (matchFrom(nextActual, selectorIndex + 1))
+                    return true;
+            }
+            return false;
+        }
+        if (actualIndex >= actualSegments.length)
+            return false;
+        if (selectorSegment === '*') {
+            return matchFrom(actualIndex + 1, selectorIndex + 1);
+        }
+        if (selectorSegment === '[*]') {
+            return /^\[\d+\]$/.test(actualSegments[actualIndex])
+                && matchFrom(actualIndex + 1, selectorIndex + 1);
+        }
+        return selectorSegment === actualSegments[actualIndex]
+            && matchFrom(actualIndex + 1, selectorIndex + 1);
+    };
+    return matchFrom(0, 0);
+}
+function collectAllowedAttributePaths(ruleIndex) {
+    const allowed = [];
+    function visit(basePath, constraints) {
+        if (basePath.includes('@')) {
+            allowed.push(basePath);
+        }
+        const attributes = constraints.attributes;
+        if (!attributes)
+            return;
+        for (const [key, childConstraints] of Object.entries(attributes)) {
+            visit(`${basePath}@${key}`, childConstraints);
+        }
+    }
+    for (const [path, rule] of ruleIndex) {
+        visit(path, rule.constraints);
+    }
+    return allowed;
+}
+function collectAttributeEntries(eventsByPath) {
+    const entries = [];
+    function visit(basePath, attributes) {
+        if (!attributes)
+            return;
+        for (const [key, entry] of attributes.entries()) {
+            const path = `${basePath}@${key}`;
+            entries.push({ path, span: entry.span });
+            visit(path, entry.attributes);
+        }
+    }
+    for (const [path, event] of eventsByPath) {
+        visit(path, event.attributes);
+    }
+    return entries;
+}
+function checkAttributePolicy(schema, ruleIndex, eventsByPath, ctx) {
+    const policy = schema.attribute_policy ?? 'inherit_world';
+    if (policy === 'inherit_world' && (schema.world ?? 'open') !== 'closed')
+        return;
+    if (policy !== 'inherit_world' && policy !== 'forbid')
+        return;
+    const attributeEntries = collectAttributeEntries(eventsByPath);
+    if (attributeEntries.length === 0)
+        return;
+    const allowedPaths = policy === 'inherit_world'
+        ? collectAllowedAttributePaths(ruleIndex)
+        : [];
+    for (const entry of attributeEntries) {
+        if (allowedPaths.some((allowedPath) => matchesAllowedPath(entry.path, allowedPath)))
+            continue;
+        emitError(ctx, createDiag(entry.path, entry.span, policy === 'forbid'
+            ? `Attribute '${entry.path}' is forbidden by schema attribute_policy`
+            : `Attribute '${entry.path}' is not allowed by closed-world schema`, ErrorCodes.UNEXPECTED_ATTRIBUTE_ENTRY));
+    }
+}
 function checkDatatypeRules(datatypeRules, eventsByPath, ctx) {
     if (!datatypeRules)
         return;
@@ -434,22 +924,43 @@ function checkDatatypeRules(datatypeRules, eventsByPath, ctx) {
             continue;
         }
         if (constraints.min_value !== undefined || constraints.max_value !== undefined) {
-            const normalized = normalizeIntegerLiteral(raw);
-            if (!normalized) {
-                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': exact integer range requires integer literal form`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            const range = normalizeRangeLiteral(event.type, raw);
+            if (!range) {
+                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': range constraints require numeric literal form`, ErrorCodes.NUMERIC_FORM_VIOLATION));
                 continue;
             }
-            const numeric = BigInt(normalized);
-            if (constraints.min_value !== undefined && numeric < BigInt(constraints.min_value)) {
-                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': expected value >= ${constraints.min_value}, got ${normalized}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            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));
                 continue;
             }
-            if (constraints.max_value !== undefined && numeric > BigInt(constraints.max_value)) {
-                emitError(ctx, createDiag(path, event.span, `Datatype rule violation for ':${event.datatype}': expected value <= ${constraints.max_value}, got ${normalized}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            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));
             }
         }
     }
 }
+function mergeDatatypeRules(ruleIndex, datatypeRules, eventsByPath) {
+    if (!datatypeRules)
+        return ruleIndex;
+    const merged = new Map();
+    for (const [path, rule] of ruleIndex.entries()) {
+        merged.set(path, { ...rule, constraints: { ...rule.constraints } });
+    }
+    for (const [path, event] of eventsByPath.entries()) {
+        if (!event.datatype)
+            continue;
+        const datatypeRule = datatypeRules[datatypeBase(event.datatype).toLowerCase()];
+        if (!datatypeRule)
+            continue;
+        const existing = merged.get(path);
+        const constraints = existing?.constraints ?? {};
+        merged.set(path, {
+            path,
+            constraints: { ...datatypeRule, ...constraints },
+        });
+    }
+    return merged;
+}
 function checkAttributeConstraints(ruleIndex, eventsByPath, datatypeRules, ctx) {
     for (const [path, rule] of ruleIndex) {
         if (!rule.constraints.attributes && rule.constraints.closed_attributes !== true)
@@ -493,9 +1004,10 @@ function validateAttributeEntry(path, entry, constraints, datatypeRules, ctx) {
             emitError(ctx, createDiag(path, entry.span, `Container kind mismatch: expected ${effectiveConstraints.type_is}, got ${entry.type}`, ErrorCodes.WRONG_CONTAINER_KIND));
         }
     }
-    if (effectiveConstraints.type !== undefined && !constraintTypeMatches(entry.type, effectiveConstraints.type, entry.raw)) {
+    if (effectiveConstraints.type !== undefined && !constraintTypeMatches(entry.type, effectiveConstraints.type, entry.raw, effectiveConstraints)) {
         emitError(ctx, createDiag(path, entry.span, `Type mismatch: expected ${effectiveConstraints.type}, got ${entry.type}`, ErrorCodes.TYPE_MISMATCH));
     }
+    checkLexicalLiteralConstraint(path, entry, effectiveConstraints, ctx);
     if (effectiveConstraints.datatype !== undefined && entry.datatype !== effectiveConstraints.datatype) {
         emitError(ctx, createDiag(path, entry.span, `Datatype mismatch: expected ${effectiveConstraints.datatype}, got ${entry.datatype ?? '<none>'}`, ErrorCodes.TYPE_MISMATCH));
     }
@@ -511,9 +1023,9 @@ function validateAttributeEntry(path, entry, constraints, datatypeRules, ctx) {
             emitError(ctx, createDiag(path, entry.span, `Reference kind mismatch at ${path}: expected ${expectedType}, got ${entry.type}`, ErrorCodes.REFERENCE_KIND_MISMATCH));
         }
     }
-    if (entry.type === 'NumberLiteral') {
-        const digitCount = countIntegerDigits(entry.raw);
-        if (effectiveConstraints.sign === 'unsigned' && isNegative(entry.raw)) {
+    if (hasDigitFormConstraints(effectiveConstraints) && isDigitFormLiteral(entry.type)) {
+        const digitCount = countFormDigits(entry.type, entry.raw);
+        if ((entry.type === 'NumberLiteral' || entry.type === 'RadixLiteral') && effectiveConstraints.sign === 'unsigned' && isFormNegative(entry.raw)) {
             emitError(ctx, createDiag(path, entry.span, `Numeric form violation: expected unsigned, got negative`, ErrorCodes.NUMERIC_FORM_VIOLATION));
         }
         if (effectiveConstraints.min_digits !== undefined && digitCount < effectiveConstraints.min_digits) {
@@ -522,15 +1034,27 @@ function validateAttributeEntry(path, entry, constraints, datatypeRules, ctx) {
         if (effectiveConstraints.max_digits !== undefined && digitCount > effectiveConstraints.max_digits) {
             emitError(ctx, createDiag(path, entry.span, `Numeric form violation: expected max ${effectiveConstraints.max_digits} digits, got ${digitCount}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
         }
+        if (entry.type === 'RadixLiteral' && effectiveConstraints.radix !== undefined) {
+            const declaredRadix = declaredRadixFromDatatype(entry.datatype);
+            if ((declaredRadix === null && effectiveConstraints.allow_unspecified_radix !== true)
+                || (declaredRadix !== null && declaredRadix !== effectiveConstraints.radix)) {
+                emitError(ctx, createDiag(path, entry.span, `Numeric form violation: expected declared radix ${effectiveConstraints.radix}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+                return;
+            }
+            const invalidDigit = firstInvalidRadixDigit(entry.raw, effectiveConstraints.radix);
+            if (invalidDigit !== null) {
+                emitError(ctx, createDiag(path, entry.span, `Numeric form violation: radix literal digit '${invalidDigit}' is outside radix ${effectiveConstraints.radix}`, ErrorCodes.NUMERIC_FORM_VIOLATION));
+            }
+        }
     }
-    if (entry.type === 'StringLiteral') {
+    if (isStringType(entry.type)) {
         if (effectiveConstraints.min_length !== undefined && entry.value.length < effectiveConstraints.min_length) {
             emitError(ctx, createDiag(path, entry.span, `String length violation: expected min length ${effectiveConstraints.min_length}, got ${entry.value.length}`, ErrorCodes.STRING_LENGTH_VIOLATION));
         }
         if (effectiveConstraints.max_length !== undefined && entry.value.length > effectiveConstraints.max_length) {
             emitError(ctx, createDiag(path, entry.span, `String length violation: expected max length ${effectiveConstraints.max_length}, got ${entry.value.length}`, ErrorCodes.STRING_LENGTH_VIOLATION));
         }
-        if (effectiveConstraints.pattern !== undefined && !(new RegExp(effectiveConstraints.pattern).test(entry.value))) {
+        if (effectiveConstraints.pattern !== undefined && !patternMatches(effectiveConstraints.pattern, entry.value)) {
             emitError(ctx, createDiag(path, entry.span, `Pattern mismatch: value does not match ${effectiveConstraints.pattern}`, ErrorCodes.PATTERN_MISMATCH));
         }
     }
@@ -554,7 +1078,13 @@ function mergeDatatypeRuleConstraints(constraints, datatype, datatypeRules) {
         return constraints;
     return { ...datatypeRule, ...constraints };
 }
-function constraintTypeMatches(actualType, expectedType, raw) {
+function constraintTypeMatches(actualType, expectedType, raw, constraints) {
+    if (constraints?.nullable === true && actualType === 'NullLiteral')
+        return true;
+    if (constraints?.allow_infinity === true && actualType === 'InfinityLiteral' && isNumericExpectedType(expectedType))
+        return true;
+    if (constraints?.allow_nan === true && actualType === 'NaNLiteral' && isNumericExpectedType(expectedType))
+        return true;
     if (actualType === expectedType)
         return true;
     if (actualType === 'NumberLiteral') {
@@ -566,6 +1096,49 @@ function constraintTypeMatches(actualType, expectedType, raw) {
     const satisfies = TYPE_ALIASES[actualType];
     return Boolean(satisfies?.includes(expectedType));
 }
+function isNumericExpectedType(expectedType) {
+    return expectedType === 'NumberLiteral' || expectedType === 'IntegerLiteral' || expectedType === 'FloatLiteral';
+}
+function checkLexicalLiteralConstraints(ruleIndex, events, ctx) {
+    for (const [path, rule] of ruleIndex) {
+        const event = events.get(path);
+        if (!event)
+            continue;
+        checkLexicalLiteralConstraint(path, event, rule.constraints, ctx);
+    }
+}
+function checkLexicalLiteralConstraint(path, event, constraints, ctx) {
+    if (event.type === 'NullLiteral' && !nullValueMatches(event.value, constraints)) {
+        emitError(ctx, createDiag(path, event.span, `Null value mismatch: expected ${formatExpectedNullValues(constraints)}, got ${event.value || '<none>'}`, ErrorCodes.NULL_VALUE_MISMATCH));
+    }
+    if (event.type === 'ToggleLiteral' && constraints.toggle_pair !== undefined && constraints.toggle_pair !== 'any') {
+        const value = (event.raw || event.value).toLowerCase();
+        const allowed = constraints.toggle_pair === 'yes_no'
+            ? ['yes', 'no']
+            : constraints.toggle_pair === 'on_off'
+                ? ['on', 'off']
+                : [];
+        if (allowed.length > 0 && !allowed.includes(value)) {
+            emitError(ctx, createDiag(path, event.span, `Toggle pair mismatch: expected ${constraints.toggle_pair}, got ${value || '<none>'}`, ErrorCodes.TOGGLE_PAIR_MISMATCH));
+        }
+    }
+}
+function nullValueMatches(value, constraints) {
+    const expected = expectedNullValues(constraints);
+    return expected.length === 0 || expected.includes(value);
+}
+function expectedNullValues(constraints) {
+    const values = [];
+    if (constraints.null_value !== undefined)
+        values.push(constraints.null_value);
+    if (constraints.null_values !== undefined)
+        values.push(...constraints.null_values);
+    return values;
+}
+function formatExpectedNullValues(constraints) {
+    const values = expectedNullValues(constraints);
+    return values.length > 0 ? values.join(' | ') : '<any>';
+}
 function isReferenceType(type) {
     return type === 'CloneReference' || type === 'PointerReference';
 }
@@ -584,17 +1157,115 @@ function datatypeTypeMatches(actualType, expectedType, raw) {
         return true;
     return false;
 }
-function normalizeIntegerLiteral(raw) {
-    if (!/^[+-]?\d[\d_]*$/.test(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))
         return null;
-    return raw.replace(/_/g, '');
+    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;
 }
 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;
+}
+function isDigitFormLiteral(type) {
+    return type === 'NumberLiteral' || type === 'HexLiteral' || type === 'RadixLiteral';
+}
+function radixConstraintMatches(datatype, raw, constraints) {
+    if (constraints.radix === undefined)
+        return true;
+    const declaredRadix = declaredRadixFromDatatype(datatype);
+    if (declaredRadix === null && constraints.allow_unspecified_radix !== true)
+        return false;
+    if (declaredRadix !== null && declaredRadix !== constraints.radix)
+        return false;
+    return firstInvalidRadixDigit(raw, constraints.radix) === null;
+}
+function declaredRadixFromDatatype(datatype) {
+    if (datatype === undefined)
+        return null;
+    const match = /^radix(?:\[(\d+)\]|(\d+))$/i.exec(datatype.trim());
+    if (!match)
+        return null;
+    const value = Number(match[1] ?? match[2]);
+    return Number.isInteger(value) && value >= 0 ? value : null;
+}
+function isStringType(type) {
+    return type === 'StringLiteral'
+        || type === 'TrimtickLiteral'
+        || type === 'TrimtickStringLiteral'
+        || type === 'SeparatorLiteral'
+        || type === 'NullLiteral'
+        || type === 'EncodingLiteral'
+        || type === 'DateLiteral'
+        || type === 'TimeLiteral'
+        || type === 'DateTimeLiteral'
+        || type === 'ZRUTDateTimeLiteral';
+}
+function countFormDigits(type, raw) {
+    if (type === 'NumberLiteral')
+        return countIntegerDigits(raw);
+    const body = raw
+        .replace(/^[#%^]/, '')
+        .replace(/^[+-]/, '')
+        .replace(/_/g, '');
+    let count = 0;
+    for (const char of body) {
+        if ((char >= '0' && char <= '9') || ((char >= 'A' && char <= 'Z') || (char >= 'a' && char <= 'z') || char === '&' || char === '!')) {
+            count++;
+        }
+    }
+    return count;
+}
+function firstInvalidRadixDigit(raw, radix) {
+    const body = raw.replace(/^%/, '').replace(/^[+-]/, '').replace(/_/g, '');
+    for (const char of body) {
+        const value = radixDigitValue(char);
+        if (value !== null && value >= radix)
+            return char;
+    }
+    return null;
+}
+function radixDigitValue(char) {
+    if (char >= '0' && char <= '9')
+        return char.charCodeAt(0) - 48;
+    const lower = char.toLowerCase();
+    if (lower >= 'a' && lower <= 'z')
+        return lower.charCodeAt(0) - 87;
+    if (char === '&')
+        return 36;
+    if (char === '!')
+        return 37;
+    return null;
+}
 function isNegative(raw) {
     return raw.startsWith('-');
 }
+function isFormNegative(raw) {
+    return /^[$#%^]?-/.test(raw) || raw.startsWith('-');
+}
 function formatCanonicalPathLocal(path) {
     if (!path || !Array.isArray(path.segments))
         return '$';