@altopelago/aeos-core 0.9.0 → 0.9.1

package/dist/validate.js

@@ -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'],
@@ -208,6 +219,9 @@ export function validate(aes, schema, options = {}) {
                     containerArity.set(pathStr, event.value.elements.length);
                     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);
+                }
                 else if (event.value.type === 'NodeLiteral' && Array.isArray(event.value.children)) {
                     containerArity.set(pathStr, event.value.children.length);
                     hydrateIndexedFallback(pathStr, event.value, toTuple(event.span));
@@ -240,33 +254,61 @@ export function validate(aes, schema, options = {}) {
     }
     // Phase 3: Build rule index from schema (run after baseline invariants)
     const ruleIndex = buildRuleIndex(schema, ctx);
+    const effectiveRuleIndex = expandWildcardRules(expandSelectorRules(ruleIndex, schema, eventsByPath, ctx), 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);
+    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 +359,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,7 +373,9 @@ 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));
     }
@@ -350,6 +400,114 @@ function resolveReferenceFormEvents(ruleIndex, eventsByPath) {
     }
     return resolved;
 }
+function expandSelectorRules(ruleIndex, schema, eventsByPath, ctx) {
+    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;
+            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) {
+    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)) {
+                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 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 (constraints.pattern !== undefined && !(new RegExp(constraints.pattern).test(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 && firstInvalidRadixDigit(event.raw, constraints.radix) !== null)
+            return false;
+    }
+    return true;
+}
 function resolveTerminalReferenceEvent(event, eventsByPath, activePaths) {
     if (!isReferenceType(event.type) || !event.referencePath) {
         return event;
@@ -404,6 +562,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,18 +765,17 @@ 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));
             }
         }
     }
@@ -493,9 +823,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 +842,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,6 +853,12 @@ 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 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 (effectiveConstraints.min_length !== undefined && entry.value.length < effectiveConstraints.min_length) {
@@ -554,7 +891,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 +909,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 +970,87 @@ 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' || type === 'SeparatorLiteral';
+}
+function isStringType(type) {
+    return type === 'StringLiteral' || type === 'TrimtickLiteral';
+}
+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') || (type !== 'SeparatorLiteral' && ((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 '$';