@altopelago/aeon-aes 0.9.0

package/dist/modes.js

@@ -0,0 +1,801 @@
+/**
+ * Phase 7 — Mode Enforcement
+ *
+ * Enforces:
+ * - Transport vs Strict mode typing rules
+ * - Toggle typing rules (no semantic toggle unless typed)
+ * - Header correctness
+ *
+ * Non-negotiable constraints:
+ * - No coercion, ever
+ * - No schema execution
+ * - No reference resolution
+ * - Fail-closed by default
+ */
+import { formatPath } from './paths.js';
+import { formatReferenceTargetPath } from './reference-target.js';
+/**
+ * Mode enforcement error
+ */
+export class ModeEnforcementError extends Error {
+    span;
+    code;
+    path;
+    constructor(message, span, code, path) {
+        super(message);
+        this.name = 'ModeEnforcementError';
+        this.span = span;
+        this.code = code;
+        this.path = path;
+    }
+}
+/**
+ * Error: Untyped value in typed mode
+ */
+export class UntypedValueInStrictModeError extends ModeEnforcementError {
+    constructor(span, path) {
+        super(`Untyped value in typed mode: '${path}' requires explicit type annotation`, span, 'UNTYPED_VALUE_IN_STRICT_MODE', path);
+        this.name = 'UntypedValueInStrictModeError';
+    }
+}
+/**
+ * Error: toggle literal requires :toggle in typed mode
+ */
+export class UntypedToggleLiteralError extends ModeEnforcementError {
+    constructor(span, path) {
+        super(`Untyped toggle literal in typed mode: '${path}' requires ':toggle' type annotation`, span, 'UNTYPED_TOGGLE_LITERAL', path);
+        this.name = 'UntypedToggleLiteralError';
+    }
+}
+export class CustomToggleAliasNotAllowedError extends ModeEnforcementError {
+    constructor(span, path, datatype) {
+        super(`Custom toggle alias not allowed at '${path}': use ':toggle' instead of ':${datatype}'`, span, 'CUSTOM_TOGGLE_ALIAS_NOT_ALLOWED', path);
+        this.name = 'CustomToggleAliasNotAllowedError';
+    }
+}
+/**
+ * Error: Structured header and shorthand header used together
+ */
+export class HeaderConflictError extends ModeEnforcementError {
+    constructor(span) {
+        super('Header conflict: cannot use both structured header (aeon:header) and shorthand header fields', span, 'HEADER_CONFLICT', '$');
+        this.name = 'HeaderConflictError';
+    }
+}
+/**
+ * Error: Reserved datatype annotation does not match literal/container kind
+ */
+export class DatatypeLiteralMismatchError extends ModeEnforcementError {
+    constructor(span, path, datatype, actualKind, expectedKinds) {
+        super(`Datatype/literal mismatch at '${path}': datatype ':${datatype}' expects ${expectedKinds.join(' or ')}, got ${actualKind}`, span, 'DATATYPE_LITERAL_MISMATCH', path);
+        this.name = 'DatatypeLiteralMismatchError';
+    }
+}
+export class InvalidCustomDatatypeBracketShapeError extends ModeEnforcementError {
+    constructor(span, path, datatype, actualKind) {
+        super(`Datatype/literal mismatch at '${path}': datatype ':${datatype}' has bracket specs incompatible with both SeparatorLiteral and RadixLiteral, got ${actualKind}`, span, 'DATATYPE_LITERAL_MISMATCH', path);
+        this.name = 'InvalidCustomDatatypeBracketShapeError';
+    }
+}
+export class IncompatibleCustomDatatypeAdornmentsError extends ModeEnforcementError {
+    constructor(span, path, datatype, actualKind) {
+        super(`Datatype/literal mismatch at '${path}': datatype ':${datatype}' combines incompatible generic and bracket constraints, got ${actualKind}`, span, 'DATATYPE_LITERAL_MISMATCH', path);
+        this.name = 'IncompatibleCustomDatatypeAdornmentsError';
+    }
+}
+/**
+ * Error: Custom datatype is not permitted by typed-mode datatype policy
+ */
+export class CustomDatatypeNotAllowedError extends ModeEnforcementError {
+    constructor(span, path, datatype) {
+        super(`Custom datatype not allowed in typed mode at '${path}': ':${datatype}' requires --datatype-policy allow_custom`, span, 'CUSTOM_DATATYPE_NOT_ALLOWED', path);
+        this.name = 'CustomDatatypeNotAllowedError';
+    }
+}
+/**
+ * Error: Node head datatype must remain :node in strict mode
+ */
+export class InvalidNodeHeadDatatypeError extends ModeEnforcementError {
+    constructor(span, path, datatype) {
+        super(`Invalid node head datatype in strict mode at '${path}': node heads must use ':node', got ':${datatype}'`, span, 'INVALID_NODE_HEAD_DATATYPE', path);
+        this.name = 'InvalidNodeHeadDatatypeError';
+    }
+}
+/**
+ * Extract mode from header
+ */
+export function extractMode(header) {
+    if (!header) {
+        return 'transport'; // Default
+    }
+    // Check for mode field
+    const modeValue = header.fields.get('mode');
+    if (modeValue && modeValue.type === 'StringLiteral') {
+        const mode = modeValue.value.toLowerCase();
+        if (mode === 'strict') {
+            return 'strict';
+        }
+        if (mode === 'custom') {
+            return 'custom';
+        }
+    }
+    return 'transport'; // Default
+}
+/**
+ * Enforce mode constraints on events
+ *
+ * In typed modes (`strict` and `custom`):
+ * - Every binding must have an explicit type annotation
+ *
+ * In strict mode only:
+ * - Untyped toggle literals (yes/no/on/off) require :toggle type
+ *
+ * In transport mode:
+ * - Untyped values are allowed (stay raw, no semantic interpretation)
+ * - Explicit datatype annotations are still validated for compatibility
+ * - Custom datatype labels are accepted by default
+ */
+export function enforceMode(events, header, options = {}) {
+    const mode = extractMode(header);
+    const datatypePolicy = options.datatypePolicy ?? defaultDatatypePolicyForMode(mode);
+    const errors = [];
+    const pathToIndex = new Map();
+    for (let i = 0; i < events.length; i++) {
+        pathToIndex.set(formatPath(events[i].path), i);
+    }
+    // Header correctness: structured vs shorthand mutual exclusion
+    if (header && header.hasStructured && header.hasShorthand) {
+        errors.push(new HeaderConflictError(header.span));
+    }
+    for (const event of events) {
+        // Shorthand header metadata is control-plane information, not payload.
+        // Structured header payload bindings still follow normal typing rules,
+        // except for the mode selector itself so strict mode can be declared.
+        if (shouldSkipHeaderEvent(event, header)) {
+            continue;
+        }
+        // Indexed list/tuple element events are synthetic structural nodes.
+        // Strict typing is enforced on declared bindings and nested members.
+        if (isIndexedElementEvent(event)) {
+            continue;
+        }
+        if (!event.datatype) {
+            if (mode === 'strict' || mode === 'custom') {
+                if (mode === 'strict' && event.value.type === 'ToggleLiteral') {
+                    errors.push(new UntypedToggleLiteralError(event.span, formatPath(event.path)));
+                }
+                else {
+                    errors.push(new UntypedValueInStrictModeError(event.span, formatPath(event.path)));
+                }
+            }
+            continue;
+        }
+        const expectedKinds = expectedKindsForReservedDatatype(event.datatype);
+        const actualKind = resolveDatatypeCheckKind(event, events, pathToIndex) ?? event.value.type;
+        if (datatypeBase(event.datatype) === 'switch' && actualKind === 'ToggleLiteral') {
+            errors.push(new CustomToggleAliasNotAllowedError(event.span, formatPath(event.path), event.datatype));
+            continue;
+        }
+        if ((mode === 'strict' || mode === 'custom') && !expectedKinds && datatypePolicy === 'reserved_only') {
+            errors.push(new CustomDatatypeNotAllowedError(event.span, formatPath(event.path), event.datatype));
+            continue;
+        }
+        if (mode === 'strict' && !expectedKinds && actualKind === 'ToggleLiteral') {
+            errors.push(new CustomToggleAliasNotAllowedError(event.span, formatPath(event.path), event.datatype));
+            continue;
+        }
+        if (expectedKinds && !expectedKinds.includes(actualKind)) {
+            errors.push(new DatatypeLiteralMismatchError(event.span, formatPath(event.path), event.datatype, actualKind, expectedKinds));
+        }
+        if (!expectedKinds) {
+            const customShape = classifyCustomDatatypeShape(event.datatype);
+            if (customShape === 'invalid_both' && (actualKind === 'SeparatorLiteral' || actualKind === 'RadixLiteral')) {
+                errors.push(new InvalidCustomDatatypeBracketShapeError(event.span, formatPath(event.path), event.datatype, actualKind));
+            }
+            else {
+                const customExpectedKinds = expectedKindsForCustomDatatype(event.datatype, customShape);
+                if (customExpectedKinds && customExpectedKinds.length === 0) {
+                    errors.push(new IncompatibleCustomDatatypeAdornmentsError(event.span, formatPath(event.path), event.datatype, actualKind));
+                }
+                else if (customExpectedKinds && !customExpectedKinds.includes(actualKind)) {
+                    errors.push(new DatatypeLiteralMismatchError(event.span, formatPath(event.path), event.datatype, actualKind, customExpectedKinds));
+                }
+            }
+        }
+        errors.push(...validateAnnotationEntries(event.annotations, formatPath(event.path), event.span, events, pathToIndex, mode, datatypePolicy));
+        errors.push(...validateAnonymousTypedValues(event.value, formatPath(event.path), event.span, events, pathToIndex, mode, datatypePolicy));
+        errors.push(...validateNodeHeadDatatypes(event.value, formatPath(event.path), event.span, mode));
+    }
+    // Fail-closed: return empty events if errors exist
+    if (errors.length > 0 && !options.recovery) {
+        return { events: [], errors };
+    }
+    return { events, errors };
+}
+function defaultDatatypePolicyForMode(mode) {
+    return mode === 'strict' ? 'reserved_only' : 'allow_custom';
+}
+function isModeSelectorHeaderEvent(event) {
+    return event.path.segments.length === 2
+        && event.path.segments[0]?.type === 'root'
+        && event.path.segments[1]?.type === 'member'
+        && event.path.segments[1].key === 'aeon:mode';
+}
+function shouldSkipHeaderEvent(event, header) {
+    if (!header) {
+        return false;
+    }
+    if (header.hasShorthand && isTopLevelHeaderEvent(event)) {
+        return true;
+    }
+    return isModeSelectorHeaderEvent(event);
+}
+function isTopLevelHeaderEvent(event) {
+    return event.path.segments.length === 2
+        && event.path.segments[0]?.type === 'root'
+        && event.path.segments[1]?.type === 'member'
+        && event.path.segments[1].key.startsWith('aeon:');
+}
+// Legacy export for backward compatibility
+export function validateMode(_mode) {
+    return [];
+}
+function isIndexedElementEvent(event) {
+    const lastSegment = event.path.segments[event.path.segments.length - 1];
+    return lastSegment?.type === 'index';
+}
+function resolveDatatypeCheckKind(event, events, pathToIndex, stack = []) {
+    const resolved = resolveReferenceValue(event.value, events, pathToIndex);
+    if (!resolved) {
+        return null;
+    }
+    if ((resolved.type === 'CloneReference' || resolved.type === 'PointerReference')) {
+        const resolution = resolveReferenceTarget(resolved.path, events, pathToIndex);
+        if (!resolution || stack.includes(resolution.targetPath)) {
+            return resolved.type;
+        }
+        if (!resolution.event) {
+            return resolved.type;
+        }
+        return resolveDatatypeCheckKind(resolution.event, events, pathToIndex, [...stack, resolution.targetPath]) ?? resolved.type;
+    }
+    return resolvedValueKind(resolved);
+}
+function resolvedValueKind(value) {
+    if (value.type === 'TypedValue') {
+        return resolvedValueKind(value.value);
+    }
+    if (value.type === 'StringLiteral') {
+        return value.trimticks ? 'TrimtickStringLiteral' : 'StringLiteral';
+    }
+    if (value.type === 'DateTimeLiteral') {
+        return value.raw.includes('&') ? 'ZRUTDateTimeLiteral' : 'DateTimeLiteral';
+    }
+    if (value.type === 'SeparatorLiteral') {
+        return 'SeparatorLiteral';
+    }
+    if (value.type === 'HexLiteral') {
+        return hasValidLiteralUnderscores(value.raw) ? 'HexLiteral' : 'InvalidHexLiteral';
+    }
+    if (value.type === 'RadixLiteral') {
+        return hasValidRadixLiteral(value.raw) ? 'RadixLiteral' : 'InvalidRadixLiteral';
+    }
+    if (value.type === 'EncodingLiteral') {
+        return hasValidEncodingLiteral(value.raw) ? 'EncodingLiteral' : 'InvalidEncodingLiteral';
+    }
+    return value.type;
+}
+function validateAnonymousTypedValues(value, ownerPath, span, events, pathToIndex, mode, datatypePolicy) {
+    const errors = [];
+    if (value.type === 'TypedValue') {
+        if (value.datatype) {
+            const datatype = formatTypeAnnotation(value.datatype);
+            const expectedKinds = expectedKindsForReservedDatatype(datatype);
+            const resolved = resolveReferenceValue(value.value, events, pathToIndex) ?? value.value;
+            const actualKind = resolvedValueKind(resolved);
+            if (datatypeBase(datatype) === 'switch' && actualKind === 'ToggleLiteral') {
+                errors.push(new CustomToggleAliasNotAllowedError(value.span, ownerPath, datatype));
+            }
+            else if ((mode === 'strict' || mode === 'custom') && !expectedKinds && datatypePolicy === 'reserved_only') {
+                errors.push(new CustomDatatypeNotAllowedError(value.span, ownerPath, datatype));
+            }
+            else {
+                if (mode === 'strict' && !expectedKinds && actualKind === 'ToggleLiteral') {
+                    errors.push(new CustomToggleAliasNotAllowedError(value.span, ownerPath, datatype));
+                }
+                else if (expectedKinds && !expectedKinds.includes(actualKind)) {
+                    errors.push(new DatatypeLiteralMismatchError(value.span, ownerPath, datatype, actualKind, expectedKinds));
+                }
+                else if (!expectedKinds) {
+                    const customShape = classifyCustomDatatypeShape(datatype);
+                    if (customShape === 'invalid_both' && (actualKind === 'SeparatorLiteral' || actualKind === 'RadixLiteral')) {
+                        errors.push(new InvalidCustomDatatypeBracketShapeError(value.span, ownerPath, datatype, actualKind));
+                    }
+                    else {
+                        const customExpectedKinds = expectedKindsForCustomDatatype(datatype, customShape);
+                        if (customExpectedKinds && customExpectedKinds.length === 0) {
+                            errors.push(new IncompatibleCustomDatatypeAdornmentsError(value.span, ownerPath, datatype, actualKind));
+                        }
+                        else if (customExpectedKinds && !customExpectedKinds.includes(actualKind)) {
+                            errors.push(new DatatypeLiteralMismatchError(value.span, ownerPath, datatype, actualKind, customExpectedKinds));
+                        }
+                    }
+                }
+            }
+        }
+        errors.push(...validateAnonymousTypedValues(value.value, ownerPath, span, events, pathToIndex, mode, datatypePolicy));
+        return errors;
+    }
+    if (value.type === 'ObjectNode') {
+        for (const binding of value.bindings) {
+            errors.push(...validateAnonymousTypedValues(binding.value, `${ownerPath}.${binding.key}`, span, events, pathToIndex, mode, datatypePolicy));
+        }
+        return errors;
+    }
+    if (value.type === 'ListNode' || value.type === 'TupleLiteral') {
+        for (let i = 0; i < value.elements.length; i++) {
+            errors.push(...validateAnonymousTypedValues(value.elements[i], `${ownerPath}[${i}]`, span, events, pathToIndex, mode, datatypePolicy));
+        }
+        return errors;
+    }
+    if (value.type === 'NodeLiteral') {
+        for (let i = 0; i < value.children.length; i++) {
+            errors.push(...validateAnonymousTypedValues(value.children[i], `${ownerPath}[${i}]`, span, events, pathToIndex, mode, datatypePolicy));
+        }
+    }
+    return errors;
+}
+function hasValidLiteralUnderscores(raw) {
+    const body = raw.slice(1);
+    return body.length > 0 && !body.startsWith('_') && !body.endsWith('_') && !body.includes('__');
+}
+function isValidRadixDigit(c) {
+    return /[0-9A-Za-z&!]/.test(c);
+}
+function hasValidRadixLiteral(raw) {
+    const body = raw.slice(1);
+    if (body.length === 0)
+        return false;
+    let index = 0;
+    if (body[index] === '+' || body[index] === '-')
+        index += 1;
+    if (index >= body.length)
+        return false;
+    let sawDigit = false;
+    let sawDecimal = false;
+    let prevWasDigit = false;
+    let sawDigitBeforeDecimal = false;
+    for (; index < body.length; index += 1) {
+        const c = body[index];
+        if (isValidRadixDigit(c)) {
+            sawDigit = true;
+            prevWasDigit = true;
+            if (!sawDecimal)
+                sawDigitBeforeDecimal = true;
+            continue;
+        }
+        if (c === '_') {
+            if (!prevWasDigit || index + 1 >= body.length || !isValidRadixDigit(body[index + 1]))
+                return false;
+            prevWasDigit = false;
+            continue;
+        }
+        if (c === '.') {
+            if (sawDecimal || index + 1 >= body.length || !isValidRadixDigit(body[index + 1]))
+                return false;
+            if (!prevWasDigit && sawDigitBeforeDecimal)
+                return false;
+            sawDecimal = true;
+            prevWasDigit = false;
+            continue;
+        }
+        return false;
+    }
+    return sawDigit && prevWasDigit;
+}
+function hasValidEncodingLiteral(raw) {
+    const body = raw.slice(1);
+    if (body.length === 0)
+        return false;
+    if (!/^[A-Za-z0-9+/_-]+={0,2}$/.test(body))
+        return false;
+    const firstPadding = body.indexOf('=');
+    if (firstPadding === -1)
+        return true;
+    return /^=+$/.test(body.slice(firstPadding));
+}
+function validateAnnotationEntries(annotations, ownerPath, span, events, pathToIndex, mode, datatypePolicy) {
+    if (!annotations || annotations.size === 0) {
+        return [];
+    }
+    const errors = [];
+    for (const [key, entry] of annotations) {
+        const attrPath = `${ownerPath}@${key}`;
+        if (entry.datatype) {
+            const expectedKinds = expectedKindsForReservedDatatype(entry.datatype);
+            if ((mode === 'strict' || mode === 'custom') && !expectedKinds && datatypePolicy === 'reserved_only') {
+                errors.push(new CustomDatatypeNotAllowedError(span, attrPath, entry.datatype));
+            }
+            else {
+                const resolved = resolveReferenceValue(entry.value, events, pathToIndex) ?? entry.value;
+                const actualKind = resolvedValueKind(resolved);
+                if (expectedKinds && !expectedKinds.includes(actualKind)) {
+                    errors.push(new DatatypeLiteralMismatchError(span, attrPath, entry.datatype, actualKind, expectedKinds));
+                }
+                if (!expectedKinds) {
+                    const customShape = classifyCustomDatatypeShape(entry.datatype);
+                    if (customShape === 'invalid_both' && (actualKind === 'SeparatorLiteral' || actualKind === 'RadixLiteral')) {
+                        errors.push(new InvalidCustomDatatypeBracketShapeError(span, attrPath, entry.datatype, actualKind));
+                    }
+                    else {
+                        const customExpectedKinds = expectedKindsForCustomDatatype(entry.datatype, customShape);
+                        if (customExpectedKinds && customExpectedKinds.length === 0) {
+                            errors.push(new IncompatibleCustomDatatypeAdornmentsError(span, attrPath, entry.datatype, actualKind));
+                        }
+                        else if (customExpectedKinds && !customExpectedKinds.includes(actualKind)) {
+                            errors.push(new DatatypeLiteralMismatchError(span, attrPath, entry.datatype, actualKind, customExpectedKinds));
+                        }
+                    }
+                }
+            }
+        }
+        errors.push(...validateNodeHeadDatatypes(entry.value, attrPath, span, mode));
+        errors.push(...validateAnnotationEntries(entry.annotations, attrPath, span, events, pathToIndex, mode, datatypePolicy));
+    }
+    return errors;
+}
+function validateNodeHeadDatatypes(value, ownerPath, span, mode) {
+    const errors = [];
+    if (value.type === 'TypedValue') {
+        errors.push(...validateNodeHeadDatatypes(value.value, ownerPath, span, mode));
+        return errors;
+    }
+    if (value.type === 'NodeLiteral') {
+        const headDatatype = value.datatype ? formatTypeAnnotation(value.datatype) : null;
+        if (mode === 'strict' && headDatatype && value.datatype.name.toLowerCase() !== 'node') {
+            errors.push(new InvalidNodeHeadDatatypeError(span, ownerPath, headDatatype));
+        }
+        for (let i = 0; i < value.children.length; i++) {
+            errors.push(...validateNodeHeadDatatypes(value.children[i], `${ownerPath}[${i}]`, span, mode));
+        }
+        return errors;
+    }
+    if (value.type === 'ObjectNode') {
+        for (const binding of value.bindings) {
+            errors.push(...validateNodeHeadDatatypes(binding.value, `${ownerPath}.${binding.key}`, span, mode));
+        }
+        return errors;
+    }
+    if (value.type === 'ListNode' || value.type === 'TupleLiteral') {
+        for (let i = 0; i < value.elements.length; i++) {
+            errors.push(...validateNodeHeadDatatypes(value.elements[i], `${ownerPath}[${i}]`, span, mode));
+        }
+    }
+    return errors;
+}
+function formatTypeAnnotation(datatype) {
+    const name = datatype.name;
+    const generics = datatype.genericArgs.length > 0 ? `<${datatype.genericArgs.join(', ')}>` : '';
+    const radixBase = datatype.radixBase != null ? `[${datatype.radixBase}]` : '';
+    const separators = datatype.separators.map((separator) => `[${separator}]`).join('');
+    return `${name}${generics}${radixBase}${separators}`;
+}
+function isAttrSegment(segment) {
+    return typeof segment === 'object' && segment !== null && segment.type === 'attr';
+}
+function resolveReferenceValue(value, events, pathToIndex) {
+    if (value.type !== 'CloneReference' && value.type !== 'PointerReference') {
+        return unwrapTypedValue(value);
+    }
+    const resolution = resolveReferenceTarget(value.path, events, pathToIndex);
+    if (!resolution) {
+        return null;
+    }
+    return resolveReferenceSubpath(resolution.event, resolution.remainder);
+}
+function resolveReferenceTarget(path, events, pathToIndex) {
+    for (let split = path.length; split >= 1; split--) {
+        const prefix = path.slice(0, split);
+        if (prefix.some((segment) => typeof segment === 'object' && segment.type === 'attr')) {
+            continue;
+        }
+        const prefixPath = formatReferenceTargetPath(prefix);
+        const targetIndex = pathToIndex.get(prefixPath);
+        if (targetIndex === undefined) {
+            continue;
+        }
+        const event = events[targetIndex];
+        if (!event) {
+            return null;
+        }
+        const remainder = path.slice(split);
+        if (remainder.length === 0) {
+            return { targetPath: prefixPath, event, remainder };
+        }
+        if (resolveReferenceSubpath(event, remainder)) {
+            return { targetPath: prefixPath, event, remainder };
+        }
+    }
+    return null;
+}
+function resolveReferenceSubpath(event, remainder) {
+    let context = {
+        value: event.value,
+        annotations: selectAnnotations(event.annotations, event.value),
+    };
+    for (const segment of remainder) {
+        if (isAttrSegment(segment)) {
+            const attrEntry = context.annotations?.get(segment.key);
+            if (!attrEntry)
+                return null;
+            context = {
+                value: attrEntry.value,
+                annotations: selectAnnotations(attrEntry.annotations, attrEntry.value),
+            };
+            continue;
+        }
+        if (typeof segment === 'string') {
+            const value = unwrapTypedValue(context.value);
+            if (value.type !== 'ObjectNode')
+                return null;
+            const binding = value.bindings.find((candidate) => candidate.key === segment);
+            if (!binding)
+                return null;
+            context = {
+                value: binding.value,
+                annotations: selectAnnotations(buildAnnotationMap(binding.attributes), binding.value),
+            };
+            continue;
+        }
+        if (typeof segment === 'number') {
+            const value = unwrapTypedValue(context.value);
+            if (value.type !== 'ListNode' && value.type !== 'TupleLiteral')
+                return null;
+            const element = value.elements[segment];
+            if (!element)
+                return null;
+            context = {
+                value: element,
+                annotations: selectAnnotations(undefined, element),
+            };
+            continue;
+        }
+        return null;
+    }
+    return context.value;
+}
+function selectAnnotations(preferred, value) {
+    if (preferred && preferred.size > 0)
+        return preferred;
+    if (value.type === 'TypedValue' && value.attributes.length > 0) {
+        return buildAnnotationMap(value.attributes);
+    }
+    return buildValueAnnotationMap(unwrapTypedValue(value));
+}
+function unwrapTypedValue(value) {
+    return value.type === 'TypedValue' ? value.value : value;
+}
+function buildValueAnnotationMap(value) {
+    if (value.type !== 'ObjectNode'
+        && value.type !== 'ListNode'
+        && value.type !== 'TupleLiteral'
+        && value.type !== 'NodeLiteral') {
+        return undefined;
+    }
+    return buildAnnotationMap(value.attributes);
+}
+function buildAnnotationMap(attributes) {
+    if (!attributes || attributes.length === 0)
+        return undefined;
+    const result = new Map();
+    for (const attribute of attributes) {
+        for (const [key, entry] of attribute.entries) {
+            const mapped = { value: entry.value };
+            const nested = buildAnnotationMap(entry.attributes);
+            if (nested) {
+                mapped.annotations = nested;
+            }
+            result.set(key, mapped);
+        }
+    }
+    return result;
+}
+function expectedKindsForReservedDatatype(datatype) {
+    const base = datatypeBase(datatype);
+    // Reserved scalar and container names validated by strict mode.
+    // Custom datatypes intentionally remain unconstrained.
+    if (NUMERIC_TYPES.has(base))
+        return ['NumberLiteral'];
+    if (base === 'infinity')
+        return ['InfinityLiteral'];
+    if (base === 'nan')
+        return ['NaNLiteral'];
+    if (base === 'string')
+        return ['StringLiteral'];
+    if (base === 'trimtick' || base === 'prose')
+        return ['TrimtickStringLiteral'];
+    if (base === 'boolean' || base === 'bool')
+        return ['BooleanLiteral'];
+    if (base === 'toggle')
+        return ['ToggleLiteral'];
+    if (base === 'hex')
+        return ['HexLiteral'];
+    if (RADIX_TYPES.has(base))
+        return ['RadixLiteral'];
+    if (ENCODING_TYPES.has(base))
+        return ['EncodingLiteral'];
+    if (base === 'date')
+        return ['DateLiteral'];
+    if (base === 'time')
+        return ['TimeLiteral'];
+    if (base === 'datetime')
+        return ['DateTimeLiteral'];
+    if (base === 'zrut')
+        return ['ZRUTDateTimeLiteral'];
+    if (SEPARATOR_TYPES.has(base))
+        return ['SeparatorLiteral'];
+    if (base === 'tuple')
+        return ['TupleLiteral'];
+    if (base === 'list')
+        return ['ListNode'];
+    if (OBJECT_TYPES.has(base))
+        return ['ObjectNode'];
+    if (base === 'node')
+        return ['NodeLiteral'];
+    if (base === 'null')
+        return ['NullLiteral'];
+    return null;
+}
+function datatypeBase(datatype) {
+    const genericIdx = datatype.indexOf('<');
+    const separatorIdx = datatype.indexOf('[');
+    const endIdx = [genericIdx, separatorIdx]
+        .filter((idx) => idx >= 0)
+        .reduce((min, idx) => Math.min(min, idx), datatype.length);
+    return datatype.slice(0, endIdx);
+}
+export function datatypeHasGenericArgs(datatype) {
+    let bracketDepth = 0;
+    let genericStart = -1;
+    for (let index = 0; index < datatype.length; index += 1) {
+        const char = datatype[index];
+        if (char === '[') {
+            bracketDepth += 1;
+            continue;
+        }
+        if (char === ']') {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if (bracketDepth > 0) {
+            continue;
+        }
+        if (char === '<') {
+            genericStart = index;
+            continue;
+        }
+        if (char === '>' && genericStart >= 0) {
+            return true;
+        }
+    }
+    return false;
+}
+function expectedKindsForCustomDatatype(datatype, customShape) {
+    let expectedKinds = null;
+    if (datatypeHasGenericArgs(datatype)) {
+        expectedKinds = ['ListNode', 'TupleLiteral'];
+    }
+    const bracketKinds = expectedKindsForCustomDatatypeShape(customShape);
+    if (bracketKinds === null) {
+        return expectedKinds;
+    }
+    if (expectedKinds === null) {
+        return bracketKinds;
+    }
+    const combined = expectedKinds.filter((kind) => bracketKinds.includes(kind));
+    return combined;
+}
+function expectedKindsForCustomDatatypeShape(customShape) {
+    if (customShape === 'none' || customShape === 'invalid_both')
+        return null;
+    if (customShape === 'both')
+        return ['SeparatorLiteral', 'RadixLiteral'];
+    if (customShape === 'separator')
+        return ['SeparatorLiteral'];
+    return ['RadixLiteral'];
+}
+function classifyCustomDatatypeShape(datatype) {
+    const specs = bracketSpecs(datatype);
+    if (specs.length === 0)
+        return 'none';
+    const separatorOk = specs.every(isValidSeparatorSpec);
+    const radixOk = specs.length === 1 && isValidRadixBaseSpec(specs[0]);
+    if (separatorOk && radixOk)
+        return 'both';
+    if (separatorOk)
+        return 'separator';
+    if (radixOk)
+        return 'radix';
+    return 'invalid_both';
+}
+function bracketSpecs(datatype) {
+    const specs = [];
+    let genericDepth = 0;
+    let bracketStart = -1;
+    for (let index = 0; index < datatype.length; index += 1) {
+        const char = datatype[index];
+        if (char === '<') {
+            genericDepth += 1;
+            continue;
+        }
+        if (char === '>') {
+            genericDepth = Math.max(0, genericDepth - 1);
+            continue;
+        }
+        if (genericDepth > 0) {
+            continue;
+        }
+        if (char === '[') {
+            bracketStart = index + 1;
+            continue;
+        }
+        if (char === ']' && bracketStart >= 0) {
+            specs.push(datatype.slice(bracketStart, index));
+            bracketStart = -1;
+        }
+    }
+    if (datatypeBase(datatype) === 'radix' && specs.length > 0) {
+        return specs.slice(1);
+    }
+    return specs;
+}
+function isValidSeparatorSpec(spec) {
+    return /^[A-Za-z0-9!#$%&*+\-.:;=?@^_|~<>]$/.test(spec);
+}
+function isValidRadixBaseSpec(spec) {
+    if (!/^[1-9]\d*$/.test(spec))
+        return false;
+    const value = Number(spec);
+    return Number.isInteger(value) && value >= 2 && value <= 64;
+}
+const NUMERIC_TYPES = new Set([
+    'number',
+    'n',
+    'int',
+    'int8',
+    'int16',
+    'int32',
+    'int64',
+    'uint',
+    'uint8',
+    'uint16',
+    'uint32',
+    'uint64',
+    'float',
+    'float32',
+    'float64',
+]);
+const RADIX_TYPES = new Set([
+    'radix',
+    'radix2',
+    'radix6',
+    'radix8',
+    'radix12',
+]);
+const ENCODING_TYPES = new Set([
+    'encoding',
+    'base64',
+    'embed',
+    'inline',
+]);
+const SEPARATOR_TYPES = new Set([
+    'sep',
+    'set',
+]);
+const OBJECT_TYPES = new Set([
+    'object',
+    'obj',
+    'envelope',
+    'o',
+]);
+//# sourceMappingURL=modes.js.map