@virune/compiler 1.1.0-rc.0

package/dist/src/checker/checker.js

@@ -0,0 +1,2985 @@
+import { analyzeControlFlow } from '../analysis/control-flow.js';
+import { DiagnosticBag } from '../diagnostics/diagnostic.js';
+import { Scope, SymbolFactory } from '../binder/symbols.js';
+import { TypeArena } from '../types/types.js';
+import { builtinMember } from './builtin-members.js';
+import { EffectRegistry } from './effect-registry.js';
+import { TypeOperations } from './type-operations.js';
+export class TypeChecker {
+    arena = new TypeArena();
+    diagnostics = new DiagnosticBag();
+    globalScope = new Scope();
+    #factory = new SymbolFactory();
+    #symbols = new Map();
+    #namedTypes = new Map();
+    #recordDeclarations = new Map();
+    #enumDeclarations = new Map();
+    #typeAliasDeclarations = new Map();
+    #newtypeDeclarations = new Map();
+    #effects = new EffectRegistry();
+    #variants = new Map();
+    #currentFunction;
+    #loopDepth = 0;
+    #currentComponentChildrenSlots = 0;
+    #signatureOnlyNodeIds;
+    #typeOnlyNodeIds;
+    #platform;
+    #moduleId;
+    #types;
+    #jsInteropProvider;
+    #containingFile;
+    #interopUsages = [];
+    #callableProjections = [];
+    #objectCallableProjections = [];
+    #frontendCallableProjections = [];
+    #moduleWitnesses = [];
+    #semanticOrder = 0;
+    #requiresJavaScriptInitialization = false;
+    constructor(options = {}) {
+        this.#signatureOnlyNodeIds = options.signatureOnlyNodeIds ?? new Set();
+        this.#typeOnlyNodeIds = options.typeOnlyNodeIds ?? new Set();
+        this.#platform = options.platform ?? 'neutral';
+        this.#moduleId = options.moduleId ?? '<module>';
+        this.#containingFile = options.containingFile ?? this.#moduleId;
+        this.#jsInteropProvider = options.jsInteropProvider;
+        this.#types = new TypeOperations({ arena: this.arena, diagnostics: this.diagnostics });
+    }
+    check(module) {
+        this.registerBuiltins(module.span);
+        this.registerForeignImports(module);
+        this.registerTypes(module);
+        this.finalizeTypes();
+        this.registerValues(module);
+        for (const declaration of module.declarations)
+            this.checkDeclaration(declaration);
+        return { arena: this.arena, diagnostics: this.diagnostics, globalScope: this.globalScope, symbols: this.#symbols, namedTypes: this.#namedTypes, frontendCallableProjections: this.#frontendCallableProjections, interop: { usages: this.#interopUsages, usageIR: this.#interopUsages.map(stableForeignUsage), callableProjections: this.#callableProjections, objectCallableProjections: this.#objectCallableProjections, moduleWitnesses: this.#moduleWitnesses, requiresJavaScriptInitialization: this.#requiresJavaScriptInitialization } };
+    }
+    registerForeignImports(module) {
+        for (const declaration of module.imports) {
+            if (declaration.sourceKind !== 'javascript')
+                continue;
+            if (declaration.public)
+                this.diagnostics.error('L4207', 'JavaScript imports cannot be publicly re-exported; wrap the value in a Virune newtype or adapter', declaration.span);
+            if (/^\.{1,2}\//u.test(declaration.source) && declaration.source.endsWith('.ts') && !declaration.source.endsWith('.interop.ts'))
+                this.diagnostics.error('L4210', 'Direct TypeScript imports are not executed at runtime; rename the file to *.interop.ts so Virune can type-check and emit it', declaration.span);
+            if (declaration.typeOnly && (declaration.defaultImport !== undefined || declaration.namespaceImport !== undefined)) {
+                this.diagnostics.error('L4208', 'Type-only JavaScript imports support named imports only in v1', declaration.span);
+                continue;
+            }
+            this.#requiresJavaScriptInitialization = this.#requiresJavaScriptInitialization || !declaration.typeOnly;
+            const bindings = [];
+            if (declaration.defaultImport !== undefined)
+                bindings.push({ local: declaration.defaultImport, imported: 'default', kind: declaration.typeOnly ? 'type-only' : 'default', span: declaration.span });
+            else if (declaration.namespaceImport !== undefined)
+                bindings.push({ local: declaration.namespaceImport, imported: '*', kind: declaration.typeOnly ? 'type-only' : 'namespace', span: declaration.span });
+            else if (declaration.items.length > 0)
+                for (const item of declaration.items)
+                    bindings.push({ local: item.local, imported: item.imported, kind: declaration.typeOnly ? 'type-only' : 'named', span: item.span });
+            else
+                bindings.push({ kind: 'side-effect', span: declaration.span });
+            if (this.#jsInteropProvider === undefined) {
+                this.diagnostics.error('L4200', `JavaScript import ${declaration.source} requires a JavaScript interop provider`, declaration.span);
+                continue;
+            }
+            for (const binding of bindings) {
+                try {
+                    const resolution = this.#jsInteropProvider.resolveImport({ containingFile: this.#containingFile, moduleSpecifier: declaration.source, kind: binding.kind, ...(binding.imported === undefined ? {} : { importedName: binding.imported }), platform: this.#platform });
+                    this.#moduleWitnesses.push(resolution.witness);
+                    if (binding.kind === 'named' && resolution.witness.runtimeFormat === 'commonjs') {
+                        this.diagnostics.error('L4211', `Named imports from CommonJS module ${declaration.source} are not portable; use a default or namespace import, or a TypeScript interop adapter`, binding.span);
+                        continue;
+                    }
+                    if (resolution.type?.category === 'any') {
+                        this.diagnostics.error('L4212', `JavaScript import ${binding.imported ?? declaration.source} resolves to TypeScript any; expose unknown through an interop adapter or use unsafe extern js`, binding.span);
+                        continue;
+                    }
+                    if (binding.local === undefined || resolution.type === undefined)
+                        continue;
+                    const typeId = this.arena.foreign(resolution.type);
+                    const symbol = this.#factory.create(binding.local, 'import', typeId, binding.span, { public: declaration.public, typeOnly: declaration.typeOnly });
+                    if (!this.globalScope.define(symbol))
+                        this.diagnostics.error('L1001', `Duplicate definition ${binding.local}`, binding.span);
+                    else
+                        this.#symbols.set(symbol.id, symbol);
+                    this.#interopUsages.push({ kind: 'import', nodeId: declaration.id, span: declaration.span, foreignType: resolution.type, runtimeImport: resolution.runtime, moduleWitness: resolution.witness });
+                }
+                catch (error) {
+                    this.diagnostics.error('L4201', `Cannot resolve JavaScript import ${declaration.source}: ${error instanceof Error ? error.message : String(error)}`, declaration.span);
+                }
+            }
+        }
+    }
+    registerBuiltins(span) {
+        for (const effect of ['Console', 'Task', 'File', 'Process', 'Network', 'Timer', 'Clock', 'Storage', 'Dom', 'Random', 'JavaScript'])
+            this.#effects.registerBuiltin(effect);
+        for (const [name, type] of [
+            ['Bool', this.arena.bool], ['Int', this.arena.int], ['Float', this.arena.float], ['BigInt', this.arena.bigint], ['String', this.arena.string],
+            ['Unit', this.arena.unit], ['Unknown', this.arena.unknown], ['Never', this.arena.never],
+        ])
+            this.#namedTypes.set(name, type);
+        const jsError = this.arena.add({ kind: 'named', name: 'JsError', definitionId: 'std:JsError', declarationKind: 'record', arguments: [], fields: new Map([['name', this.arena.string], ['message', this.arena.string]]) });
+        this.#namedTypes.set('JsError', jsError);
+        const jsonError = this.arena.add({ kind: 'named', name: 'JsonError', definitionId: 'std:JsonError', declarationKind: 'record', arguments: [], fields: new Map([['path', this.arena.string], ['expected', this.arena.string], ['actual', this.arena.string], ['message', this.arena.string]]) });
+        this.#namedTypes.set('JsonError', jsonError);
+        const duration = this.arena.add({ kind: 'named', name: 'Duration', definitionId: 'std:Duration', declarationKind: 'newtype', arguments: [], underlying: this.arena.int });
+        this.#namedTypes.set('Duration', duration);
+        const taskTimeoutError = this.arena.add({ kind: 'named', name: 'TaskTimeoutError', definitionId: 'std:TaskTimeoutError', declarationKind: 'record', arguments: [], fields: new Map([['milliseconds', this.arena.int]]) });
+        this.#namedTypes.set('TaskTimeoutError', taskTimeoutError);
+        const supervisorRestartLimitError = this.arena.add({ kind: 'named', name: 'SupervisorRestartLimitError', definitionId: 'std:SupervisorRestartLimitError', declarationKind: 'record', arguments: [], fields: new Map([['restarts', this.arena.int]]) });
+        this.#namedTypes.set('SupervisorRestartLimitError', supervisorRestartLimitError);
+        const bytes = this.arena.add({ kind: 'named', name: 'Bytes', definitionId: 'std:Bytes', declarationKind: 'newtype', arguments: [], underlying: this.arena.unknown, derives: new Set(['Eq', 'Hash', 'Debug']) });
+        const mutableBytes = this.arena.add({ kind: 'named', name: 'MutableBytes', definitionId: 'std:MutableBytes', declarationKind: 'newtype', arguments: [], underlying: this.arena.unknown, mustUse: true });
+        this.#namedTypes.set('Bytes', bytes);
+        this.#namedTypes.set('MutableBytes', mutableBytes);
+        const byteOrder = this.arena.add({ kind: 'named', name: 'ByteOrder', definitionId: 'std:ByteOrder', declarationKind: 'enum', arguments: [], variants: new Map([['BigEndian', []], ['LittleEndian', []]]), derives: new Set(['Eq', 'Hash', 'Debug']) });
+        this.#namedTypes.set('ByteOrder', byteOrder);
+        const bytesError = this.arena.add({ kind: 'named', name: 'BytesError', definitionId: 'std:BytesError', declarationKind: 'record', arguments: [], fields: new Map([['message', this.arena.string]]), derives: new Set(['Eq', 'Hash', 'Debug']) });
+        this.#namedTypes.set('BytesError', bytesError);
+        const integerRangeError = this.arena.add({ kind: 'named', name: 'IntegerRangeError', definitionId: 'std:IntegerRangeError', declarationKind: 'record', arguments: [], fields: new Map([['type', this.arena.string], ['value', this.arena.string]]), derives: new Set(['Eq', 'Hash', 'Debug']) });
+        this.#namedTypes.set('IntegerRangeError', integerRangeError);
+        for (const [name, underlying] of [['Byte', this.arena.int], ['Int8', this.arena.int], ['UInt8', this.arena.int], ['Int16', this.arena.int], ['UInt16', this.arena.int], ['Int32', this.arena.int], ['UInt32', this.arena.int], ['Int64', this.arena.bigint], ['UInt64', this.arena.bigint]]) {
+            this.#namedTypes.set(name, this.arena.add({ kind: 'named', name, definitionId: `std:${name}`, declarationKind: 'newtype', arguments: [], underlying, derives: new Set(['Eq', 'Hash', 'Debug']) }));
+        }
+        const httpBody = this.arena.add({ kind: 'named', name: 'HttpBody', definitionId: 'std:HttpBody', declarationKind: 'enum', arguments: [], variants: new Map([['Empty', []], ['Text', [this.arena.string]], ['Bytes', [bytes]]]), derives: new Set(['Eq', 'Hash', 'Debug']) });
+        this.#namedTypes.set('HttpBody', httpBody);
+        const httpResponse = this.arena.add({ kind: 'named', name: 'HttpResponse', definitionId: 'std:HttpResponse', declarationKind: 'record', arguments: [], fields: new Map([
+                ['status', this.arena.int], ['ok', this.arena.bool], ['headers', this.arena.map(this.arena.string, this.arena.string)], ['body', httpBody],
+            ]) });
+        this.#namedTypes.set('HttpResponse', httpResponse);
+        const fileHandle = this.arena.add({ kind: 'named', name: 'FileHandle', definitionId: 'std:FileHandle', declarationKind: 'newtype', arguments: [], underlying: this.arena.unknown, mustUse: true });
+        this.#namedTypes.set('FileHandle', fileHandle);
+        const t = this.arena.variable('T');
+        const e = this.arena.variable('E');
+        this.defineBuiltin('Unit', this.arena.unit, span);
+        this.defineBuiltin('expect', this.arena.function([this.arena.bool], this.arena.unit), span);
+        this.defineBuiltin('panic', this.arena.function([this.arena.string], this.arena.never), span);
+        this.defineBuiltin('Some', this.arena.function([t], this.arena.option(t), ['T']), span);
+        this.defineBuiltin('Ok', this.arena.function([t], this.arena.result(t, e), ['T', 'E']), span);
+        this.defineBuiltin('Err', this.arena.function([e], this.arena.result(t, e), ['T', 'E']), span);
+        this.defineBuiltin('None', this.arena.option(t), span);
+        for (const namespace of ['List', 'Map', 'Set', 'Int', 'Float', 'String', 'Json', 'Console', 'Debug', 'Option', 'Result', 'Validation', 'Task', 'Duration', 'Queue', 'Stack', 'Stream', 'File', 'Path', 'Process', 'Http', 'HttpBody', 'Fetch', 'Timer', 'Storage', 'Dom', 'Crypto', 'Url', 'Bytes', 'MutableBytes', 'ByteOrder', 'Byte', 'Int8', 'UInt8', 'Int16', 'UInt16', 'Int32', 'UInt32', 'Int64', 'UInt64'])
+            this.defineBuiltin(namespace, this.arena.unknown, span);
+    }
+    defineBuiltin(name, typeId, span) {
+        const symbol = this.#factory.create(name, 'builtin', typeId, span);
+        this.globalScope.defineAllowParent(symbol);
+        this.#symbols.set(symbol.id, symbol);
+    }
+    registerTypes(module) {
+        for (const declaration of module.declarations) {
+            let declarationKind;
+            if (declaration.kind === 'RecordDeclaration')
+                declarationKind = 'record';
+            else if (declaration.kind === 'EnumDeclaration')
+                declarationKind = 'enum';
+            else if (declaration.kind === 'NewtypeDeclaration')
+                declarationKind = 'newtype';
+            else if (declaration.kind === 'TypeAliasDeclaration')
+                declarationKind = 'alias';
+            if (declarationKind === undefined)
+                continue;
+            const typeDeclaration = declaration;
+            if (this.#namedTypes.has(typeDeclaration.name)) {
+                this.diagnostics.error('L1001', `Duplicate type name ${typeDeclaration.name}`, typeDeclaration.span);
+                continue;
+            }
+            const typeId = this.arena.add({ kind: 'named', name: typeDeclaration.name, definitionId: typeDeclaration.definitionId ?? `${this.#moduleId}#${typeDeclaration.name}`, declarationKind, arguments: [] });
+            this.#namedTypes.set(typeDeclaration.name, typeId);
+            const symbol = this.#factory.create(typeDeclaration.name, 'type', typeId, typeDeclaration.span, { declaration: typeDeclaration, public: typeDeclaration.public, typeOnly: this.#typeOnlyNodeIds.has(typeDeclaration.id) });
+            typeDeclaration.symbolId = symbol.id;
+            this.#symbols.set(symbol.id, symbol);
+            if (!this.globalScope.define(symbol))
+                this.diagnostics.error('L1002', `Name ${typeDeclaration.name} is already defined`, typeDeclaration.span);
+            if (declaration.kind === 'RecordDeclaration')
+                this.#recordDeclarations.set(declaration.name, declaration);
+            if (declaration.kind === 'EnumDeclaration')
+                this.#enumDeclarations.set(declaration.name, declaration);
+            if (declaration.kind === 'TypeAliasDeclaration')
+                this.#typeAliasDeclarations.set(declaration.name, declaration);
+            if (declaration.kind === 'NewtypeDeclaration')
+                this.#newtypeDeclarations.set(declaration.name, declaration);
+        }
+    }
+    finalizeTypes() {
+        for (const [name, declaration] of this.#recordDeclarations) {
+            const typeParameters = new Map(declaration.typeParameters.map(item => [item.name, this.arena.variable(item.name)]));
+            const fields = new Map();
+            for (const field of declaration.fields) {
+                if (fields.has(field.name))
+                    this.diagnostics.error('L1003', `Duplicate field ${field.name}`, field.span);
+                const fieldType = this.resolveTypeReference(field.type, typeParameters);
+                if (this.containsOpenEffect(fieldType))
+                    this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be stored in record fields', field.span);
+                fields.set(field.name, fieldType);
+            }
+            this.arena.setNamedDetails(this.#namedTypes.get(name), { fields, derives: new Set(declaration.derives), mustUse: declaration.attributes.some(attribute => attribute.name === 'mustUse') });
+        }
+        for (const [name, declaration] of this.#newtypeDeclarations) {
+            const underlying = this.resolveTypeReference(declaration.underlying, new Map());
+            if (this.containsOpenEffect(underlying))
+                this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be stored in newtypes', declaration.span);
+            this.arena.setNamedDetails(this.#namedTypes.get(name), { underlying, mustUse: declaration.attributes.some(attribute => attribute.name === 'mustUse') });
+        }
+        for (const [name, declaration] of this.#typeAliasDeclarations) {
+            const underlying = this.resolveTypeReference(declaration.target, new Map());
+            if (this.containsOpenEffect(underlying))
+                this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be stored in type aliases', declaration.span);
+            this.arena.setNamedDetails(this.#namedTypes.get(name), { underlying });
+        }
+        for (const [name, declaration] of this.#enumDeclarations) {
+            const typeParameters = new Map(declaration.typeParameters.map(item => [item.name, this.arena.variable(item.name)]));
+            const variants = new Map();
+            for (const variant of declaration.variants) {
+                if (variants.has(variant.name) || this.globalScope.lookupCurrent(variant.name) !== undefined)
+                    this.diagnostics.error('L1004', `Duplicate enum variant ${variant.name}`, variant.span);
+                const values = variant.values.map(type => this.resolveTypeReference(type, typeParameters));
+                if (values.some(value => this.containsOpenEffect(value)))
+                    this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be stored in enum payloads', variant.span);
+                variants.set(variant.name, values);
+            }
+            this.arena.setNamedDetails(this.#namedTypes.get(name), { variants, derives: new Set(declaration.derives), mustUse: declaration.attributes.some(attribute => attribute.name === 'mustUse') });
+        }
+    }
+    registerValues(module) {
+        for (const declaration of module.declarations) {
+            if (declaration.kind === 'FunctionDeclaration') {
+                const typeParameters = new Map(declaration.typeParameters.map(item => [item.name, this.arena.variable(item.name)]));
+                const parameters = declaration.parameters.map(item => this.resolveTypeReference(item.type, typeParameters));
+                const result = declaration.returnType === undefined ? this.arena.error : this.resolveTypeReference(declaration.returnType, typeParameters);
+                const typeId = this.arena.function(parameters, result, declaration.typeParameters.map(item => item.name), declaration.async, declaration.effects);
+                const symbol = this.defineValue(declaration.name, 'function', typeId, declaration.span, declaration.public, declaration);
+                if (symbol !== undefined)
+                    declaration.symbolId = symbol.id;
+            }
+            else if (declaration.kind === 'ComponentDeclaration') {
+                const parameters = declaration.parameters.map(item => this.resolveTypeReference(item.type, new Map()));
+                const typeId = this.arena.function(parameters, this.arena.error, [], false, declaration.effects);
+                const symbol = this.defineValue(declaration.name, 'component', typeId, declaration.span, declaration.public, declaration);
+                if (symbol !== undefined)
+                    declaration.symbolId = symbol.id;
+            }
+            else if (declaration.kind === 'TopLevelLetDeclaration') {
+                const typeId = declaration.annotation === undefined ? this.arena.error : this.resolveTypeReference(declaration.annotation, new Map());
+                const symbol = this.defineValue(declaration.name, 'variable', typeId, declaration.span, declaration.public, declaration, declaration.constant);
+                if (symbol !== undefined)
+                    declaration.symbolId = symbol.id;
+            }
+            else if (declaration.kind === 'ExternDeclaration') {
+                for (const fn of declaration.functions) {
+                    const parameters = fn.parameters.map(item => this.resolveTypeReference(item.type, new Map()));
+                    const result = this.resolveTypeReference(fn.returnType, new Map());
+                    const symbol = this.defineValue(fn.name, 'extern', this.arena.function(parameters, result, [], fn.async, fn.effects), fn.span, false, fn);
+                    if (symbol !== undefined)
+                        fn.symbolId = symbol.id;
+                }
+            }
+        }
+        for (const [enumName, declaration] of this.#enumDeclarations) {
+            const enumType = this.#namedTypes.get(enumName);
+            const type = this.arena.get(enumType);
+            if (type.kind !== 'named' || type.variants === undefined)
+                continue;
+            const genericArguments = declaration.typeParameters.map(parameter => this.arena.variable(parameter.name));
+            const constructedEnumType = genericArguments.length === 0 ? enumType : this.arena.namedInstance(type, genericArguments);
+            for (const variant of declaration.variants) {
+                const valueTypes = type.variants.get(variant.name) ?? [];
+                const typeId = valueTypes.length === 0 ? constructedEnumType : this.arena.function(valueTypes, constructedEnumType, declaration.typeParameters.map(item => item.name));
+                const symbol = this.defineValue(variant.name, 'variant', typeId, variant.span, declaration.public, declaration);
+                if (symbol !== undefined) {
+                    variant.symbolId = symbol.id;
+                    this.#variants.set(variant.name, { enumType: constructedEnumType, valueTypes, symbol });
+                }
+            }
+        }
+    }
+    defineValue(name, kind, typeId, span, publicValue, declaration, constant = false) {
+        const symbol = this.#factory.create(name, kind, typeId, span, { declaration, public: publicValue, typeOnly: this.#typeOnlyNodeIds.has(declaration.id), constant });
+        if (!this.globalScope.define(symbol)) {
+            this.diagnostics.error('L1005', `Name ${name} is already defined`, span);
+            return undefined;
+        }
+        this.#symbols.set(symbol.id, symbol);
+        return symbol;
+    }
+    checkDeclaration(declaration) {
+        if (this.#signatureOnlyNodeIds.has(declaration.id))
+            return;
+        this.checkAttributes(declaration);
+        switch (declaration.kind) {
+            case 'FunctionDeclaration':
+                this.checkFunction(declaration);
+                break;
+            case 'ComponentDeclaration':
+                this.checkComponent(declaration);
+                break;
+            case 'TopLevelLetDeclaration': {
+                if (declaration.public && !declaration.constant)
+                    this.diagnostics.error('L2080', 'Only const declarations can be public', declaration.span);
+                if (declaration.public && declaration.annotation === undefined)
+                    this.diagnostics.error('L2081', 'Public const declarations require an explicit type', declaration.span);
+                const annotated = declaration.annotation === undefined ? undefined : this.resolveTypeReference(declaration.annotation, new Map());
+                const valueType = this.checkExpression(declaration.value, this.globalScope, annotated);
+                const expected = annotated ?? valueType;
+                if (this.containsOpenEffect(expected))
+                    this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be stored in top-level declarations', declaration.span);
+                if (!this.isAssignable(valueType, expected))
+                    this.typeMismatch(valueType, expected, declaration.value.span);
+                if (declaration.constant && !this.isConstantExpression(declaration.value))
+                    this.diagnostics.error('L2082', 'const initializer must be evaluable without function calls, mutable state, async work, or external values', declaration.value.span);
+                declaration.inferredTypeId = expected;
+                if (declaration.symbolId !== undefined)
+                    this.#symbols.get(declaration.symbolId).typeId = expected;
+                break;
+            }
+            case 'TestDeclaration':
+                this.checkTest(declaration);
+                break;
+            case 'RecordDeclaration':
+                this.checkRecordFieldAttributes(declaration);
+                this.checkDerives(declaration.derives, declaration.span, declaration.name);
+                break;
+            case 'EnumDeclaration':
+                this.checkDerives(declaration.derives, declaration.span, declaration.name);
+                break;
+            case 'ExternDeclaration':
+                this.checkExtern(declaration);
+                break;
+            default: break;
+        }
+    }
+    checkFunction(declaration) {
+        this.validateEffects(declaration.effects, declaration.span);
+        if (declaration.public && declaration.returnType === undefined)
+            this.diagnostics.error('L2001', 'Public functions require an explicit return type', declaration.span);
+        if ((declaration.async || declaration.typeParameters.length > 0) && declaration.returnType === undefined)
+            this.diagnostics.error('L2002', 'Async and generic functions require an explicit return type', declaration.span);
+        const scope = new Scope(this.globalScope);
+        const typeParameters = new Map(declaration.typeParameters.map(item => [item.name, this.arena.variable(item.name)]));
+        for (const parameter of declaration.parameters) {
+            if (parameter.optional)
+                this.diagnostics.error('L2114', 'Optional parameters are supported only in extern js declarations', parameter.span);
+            const typeId = this.resolveTypeReference(parameter.type, typeParameters);
+            const parameterType = this.arena.get(typeId);
+            if (this.containsOpenEffect(typeId) && !(parameterType.kind === 'function' && parameterType.effects.includes('*')))
+                this.diagnostics.error('L2113', 'uses * is allowed only on a direct non-escaping callback parameter', parameter.span);
+            const symbol = this.#factory.create(parameter.name, 'parameter', typeId, parameter.span, { declaration });
+            if (!scope.define(symbol))
+                this.diagnostics.error('L1006', `Parameter ${parameter.name} shadows an existing name`, parameter.span);
+            else {
+                parameter.symbolId = symbol.id;
+                this.#symbols.set(symbol.id, symbol);
+            }
+        }
+        const resolvedReturnType = declaration.returnType === undefined ? undefined : this.resolveTypeReference(declaration.returnType, typeParameters);
+        if (resolvedReturnType !== undefined && this.containsOpenEffect(resolvedReturnType))
+            this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be returned', declaration.returnType?.span ?? declaration.span);
+        const context = { declaration, scope, async: declaration.async, returnTypes: [], typeParameters, effects: new Set(declaration.effects), ...(resolvedReturnType === undefined ? {} : { returnType: resolvedReturnType }) };
+        if (declaration.public) {
+            for (const parameter of declaration.parameters) {
+                const symbol = parameter.symbolId === undefined ? undefined : this.#symbols.get(parameter.symbolId);
+                if (symbol !== undefined && this.containsForeignType(symbol.typeId))
+                    this.diagnostics.error('L4209', `Public function ${declaration.name} cannot expose JavaScript foreign type ${this.arena.display(symbol.typeId)}; wrap it in a Virune newtype`, parameter.span);
+            }
+            if (context.returnType !== undefined && this.containsForeignType(context.returnType))
+                this.diagnostics.error('L4209', `Public function ${declaration.name} cannot return JavaScript foreign type ${this.arena.display(context.returnType)}; wrap it in a Virune newtype`, declaration.span);
+        }
+        if (declaration.attributes.some(attribute => attribute.name === 'jsExport')) {
+            for (const parameter of declaration.parameters) {
+                const symbol = parameter.symbolId === undefined ? undefined : this.#symbols.get(parameter.symbolId);
+                if (symbol !== undefined && !this.isSafeFfiType(symbol.typeId))
+                    this.diagnostics.error('L4213', `@jsExport parameter ${parameter.name} has type ${this.arena.display(symbol.typeId)}, which cannot be fully validated at the JavaScript boundary; use Unknown and decode explicitly`, parameter.span);
+            }
+            if (context.returnType !== undefined && !this.isSafeFfiType(context.returnType))
+                this.diagnostics.error('L4213', `@jsExport return type ${this.arena.display(context.returnType)} cannot be fully validated at the JavaScript boundary; use Unknown and encode explicitly`, declaration.returnType?.span ?? declaration.span);
+        }
+        const previous = this.#currentFunction;
+        const previousLoopDepth = this.#loopDepth;
+        this.#currentFunction = context;
+        this.#loopDepth = 0;
+        if (declaration.expressionBody)
+            context.returnTypes.push(this.checkExpression(declaration.body, scope, context.returnType));
+        else
+            this.checkBlock(declaration.body, scope);
+        this.#currentFunction = previous;
+        this.#loopDepth = previousLoopDepth;
+        const inferred = context.returnType ?? this.commonType(context.returnTypes, declaration.span);
+        if (declaration.returnType !== undefined)
+            for (const typeId of context.returnTypes)
+                if (!this.isAssignable(typeId, inferred))
+                    this.typeMismatch(typeId, inferred, declaration.span);
+        if (!declaration.expressionBody) {
+            const controlFlow = analyzeControlFlow(declaration.body, this.arena);
+            if (inferred !== this.arena.unit && !controlFlow.alwaysTerminates)
+                this.diagnostics.error('L3001', `Function ${declaration.name} does not return on every path`, declaration.span);
+            for (const span of controlFlow.unreachable)
+                this.diagnostics.error('L3006', 'Unreachable statement', span);
+        }
+        declaration.inferredTypeId = inferred;
+        if (declaration.symbolId !== undefined) {
+            const symbol = this.#symbols.get(declaration.symbolId);
+            const functionType = this.arena.get(symbol.typeId);
+            if (functionType.kind === 'function')
+                symbol.typeId = this.arena.function(functionType.parameters, inferred, functionType.typeParameters, functionType.async, functionType.effects);
+        }
+    }
+    checkComponent(declaration) {
+        this.validateEffects(declaration.effects, declaration.span);
+        if (declaration.effects.includes('*'))
+            this.diagnostics.error('L2113', 'uses * is allowed only on non-escaping callback parameters', declaration.span);
+        if (declaration.public)
+            this.diagnostics.error('L4301', 'Components cannot be public; use private or internal visibility', declaration.span);
+        if (!declaration.effects.includes('JavaScript'))
+            this.diagnostics.error('L4302', 'Components require an explicit uses JavaScript effect', declaration.span);
+        const scope = new Scope(this.globalScope);
+        for (const parameter of declaration.parameters) {
+            if (parameter.optional)
+                this.diagnostics.error('L2114', 'Optional parameters are supported only in extern js declarations', parameter.span);
+            const typeId = this.resolveTypeReference(parameter.type, new Map());
+            const parameterType = this.arena.get(typeId);
+            if (this.containsOpenEffect(typeId) && !(parameterType.kind === 'function' && parameterType.effects.includes('*')))
+                this.diagnostics.error('L2113', 'uses * is allowed only on a direct non-escaping callback parameter', parameter.span);
+            const symbol = this.#factory.create(parameter.name, 'parameter', typeId, parameter.span, { declaration });
+            if (!scope.define(symbol))
+                this.diagnostics.error('L1006', `Parameter ${parameter.name} shadows an existing name`, parameter.span);
+            else {
+                parameter.symbolId = symbol.id;
+                this.#symbols.set(symbol.id, symbol);
+            }
+        }
+        const context = { declaration, scope, async: false, returnTypes: [], typeParameters: new Map(), effects: new Set(declaration.effects) };
+        const previous = this.#currentFunction;
+        const previousLoopDepth = this.#loopDepth;
+        const previousChildrenSlots = this.#currentComponentChildrenSlots;
+        this.#currentFunction = context;
+        this.#loopDepth = 0;
+        this.#currentComponentChildrenSlots = 0;
+        this.checkBlock(declaration.body, scope);
+        const controlFlow = analyzeControlFlow(declaration.body, this.arena);
+        if (!controlFlow.alwaysTerminates)
+            this.diagnostics.error('L4304', `Component ${declaration.name} must return view on every path`, declaration.span);
+        for (const span of controlFlow.unreachable)
+            this.diagnostics.error('L3006', 'Unreachable statement', span);
+        this.#currentFunction = previous;
+        this.#loopDepth = previousLoopDepth;
+        this.#currentComponentChildrenSlots = previousChildrenSlots;
+    }
+    checkTest(declaration) {
+        const scope = new Scope(this.globalScope);
+        const previous = this.#currentFunction;
+        const previousLoopDepth = this.#loopDepth;
+        this.#currentFunction = { declaration, scope, async: declaration.async, returnType: this.arena.unit, returnTypes: [], typeParameters: new Map(), effects: new Set(['*']) };
+        this.#loopDepth = 0;
+        this.checkBlock(declaration.body, scope);
+        this.#currentFunction = previous;
+        this.#loopDepth = previousLoopDepth;
+    }
+    checkExtern(declaration) {
+        for (const fn of declaration.functions) {
+            this.validateEffects(fn.effects, fn.span);
+            let optionalSeen = false;
+            for (const parameter of fn.parameters) {
+                if (parameter.optional)
+                    optionalSeen = true;
+                else if (optionalSeen)
+                    this.diagnostics.error('L2115', 'Optional extern parameters must be trailing', parameter.span);
+                const parameterType = this.resolveTypeReference(parameter.type, new Map());
+                if (!declaration.unsafe && !this.isSafeFfiType(parameterType))
+                    this.diagnostics.error('L4213', `Safe extern parameter ${parameter.name} has type ${this.arena.display(parameterType)}, which cannot be fully validated; use Unknown or an adapter`, parameter.span);
+            }
+            const returnType = this.resolveTypeReference(fn.returnType, new Map());
+            if (!declaration.unsafe) {
+                const type = this.arena.get(returnType);
+                if (type.kind !== 'result' && !(type.kind === 'future' && this.arena.get(type.value).kind === 'result'))
+                    this.diagnostics.error('L4001', `Safe extern function ${fn.name} must return Result`, fn.span);
+                if (!this.isSafeFfiType(returnType))
+                    this.diagnostics.error('L4213', `Safe extern return type ${this.arena.display(returnType)} cannot be fully validated; use Result<Unknown, E> or an adapter`, fn.returnType.span);
+            }
+        }
+    }
+    checkAttributes(declaration) {
+        const seen = new Set();
+        for (const attribute of declaration.attributes) {
+            if (seen.has(attribute.name))
+                this.diagnostics.error('L2051', `Duplicate attribute @${attribute.name}`, attribute.span);
+            seen.add(attribute.name);
+            if (attribute.name === 'jsExport') {
+                if (declaration.kind !== 'FunctionDeclaration')
+                    this.diagnostics.error('L2052', '@jsExport can be used only on functions', attribute.span);
+                else {
+                    if (!declaration.public)
+                        this.diagnostics.error('L2053', '@jsExport function must be public', attribute.span);
+                    if (declaration.typeParameters.length > 0)
+                        this.diagnostics.error('L2054', '@jsExport does not support generic functions', attribute.span);
+                    if (attribute.arguments.length > 0)
+                        this.diagnostics.error('L2055', '@jsExport does not accept arguments', attribute.span);
+                }
+            }
+            else if (attribute.name === 'mustUse') {
+                if (!['RecordDeclaration', 'EnumDeclaration', 'NewtypeDeclaration'].includes(declaration.kind))
+                    this.diagnostics.error('L2090', '@mustUse can be used only on record, enum, or newtype declarations', attribute.span);
+                if (attribute.arguments.length > 0)
+                    this.diagnostics.error('L2091', '@mustUse does not accept arguments', attribute.span);
+            }
+            else if (attribute.name === 'json') {
+                const strict = attribute.arguments.length === 1 && attribute.arguments[0]?.kind === 'IdentifierExpression' && attribute.arguments[0].name === 'strict';
+                if (declaration.kind !== 'RecordDeclaration')
+                    this.diagnostics.error('L2056', '@json can be used only on records', attribute.span);
+                else {
+                    if (!strict)
+                        this.diagnostics.error('L2057', '@json currently accepts only the strict argument', attribute.span);
+                    if (!declaration.derives.includes('Json'))
+                        this.diagnostics.error('L2058', '@json(strict) requires derives Json', attribute.span);
+                }
+            }
+            else if (attribute.name === 'repetitionHost') {
+                if (declaration.kind !== 'ExternDeclaration')
+                    this.diagnostics.error('L2130', '@repetitionHost can be used only on extern js declarations', attribute.span);
+                else {
+                    const exportName = attribute.arguments[0];
+                    const version = attribute.arguments[1];
+                    const validShape = attribute.arguments.length === 2
+                        && exportName?.kind === 'LiteralExpression' && exportName.literalKind === 'String'
+                        && version?.kind === 'LiteralExpression' && version.literalKind === 'Int';
+                    if (!validShape)
+                        this.diagnostics.error('L2131', '@repetitionHost requires exactly a String literal export name and Int literal protocol version', attribute.span);
+                    else if (version.value !== 1)
+                        this.diagnostics.error('L2132', '@repetitionHost currently supports only protocol version 1', attribute.span);
+                    if (declaration.unsafe)
+                        this.diagnostics.error('L2133', '@repetitionHost cannot target unsafe extern js declarations', attribute.span);
+                }
+            }
+            else
+                this.diagnostics.error('L2059', `Unknown attribute @${attribute.name}`, attribute.span);
+        }
+    }
+    checkRecordFieldAttributes(declaration) {
+        const jsonNames = new Set();
+        const recordTypeId = this.#namedTypes.get(declaration.name);
+        const recordType = recordTypeId === undefined ? undefined : this.arena.get(recordTypeId);
+        for (const field of declaration.fields) {
+            const seen = new Set();
+            for (const attribute of field.attributes) {
+                if (seen.has(attribute.name))
+                    this.diagnostics.error('L2078', `Duplicate field attribute @${attribute.name}`, attribute.span);
+                seen.add(attribute.name);
+                if (attribute.name === 'jsOptional') {
+                    if (attribute.arguments.length > 0)
+                        this.diagnostics.error('L2116', '@jsOptional does not accept arguments', attribute.span);
+                    const fieldType = recordType?.kind === 'named' ? recordType.fields?.get(field.name) : undefined;
+                    if (fieldType === undefined || this.arena.get(fieldType).kind !== 'option')
+                        this.diagnostics.error('L2116', '@jsOptional can be used only on Option fields', attribute.span);
+                    continue;
+                }
+                if (!declaration.derives.includes('Json'))
+                    this.diagnostics.error('L2079', `@${attribute.name} requires ${declaration.name} to derive Json`, attribute.span);
+                if (attribute.name === 'jsonName') {
+                    const argument = attribute.arguments[0];
+                    if (attribute.arguments.length !== 1 || argument?.kind !== 'LiteralExpression' || argument.literalKind !== 'String') {
+                        this.diagnostics.error('L2080', '@jsonName requires exactly one String literal', attribute.span);
+                        continue;
+                    }
+                    const name = String(argument.value);
+                    if (jsonNames.has(name))
+                        this.diagnostics.error('L2081', `Duplicate JSON field name ${name}`, attribute.span);
+                    jsonNames.add(name);
+                }
+                else if (attribute.name === 'jsonDefault') {
+                    const argument = attribute.arguments[0];
+                    if (attribute.arguments.length !== 1 || argument === undefined || !this.isJsonDefaultExpression(argument)) {
+                        this.diagnostics.error('L2082', '@jsonDefault requires exactly one compile-time constant expression', attribute.span);
+                        continue;
+                    }
+                    const expected = recordType?.kind === 'named' ? recordType.fields?.get(field.name) : undefined;
+                    const actual = this.checkExpression(argument, this.globalScope, expected);
+                    if (expected !== undefined && !this.isAssignable(actual, expected))
+                        this.typeMismatch(actual, expected, argument.span);
+                }
+                else
+                    this.diagnostics.error('L2083', `Unknown field attribute @${attribute.name}`, attribute.span);
+            }
+            if (!seen.has('jsonName')) {
+                if (jsonNames.has(field.name))
+                    this.diagnostics.error('L2081', `Duplicate JSON field name ${field.name}`, field.span);
+                jsonNames.add(field.name);
+            }
+        }
+    }
+    isJsonDefaultExpression(expression) {
+        switch (expression.kind) {
+            case 'LiteralExpression': return true;
+            case 'IdentifierExpression': return expression.name === 'None' || expression.name === 'Unit';
+            case 'ListExpression': return expression.items.every(item => this.isJsonDefaultExpression(item));
+            case 'TupleExpression': return expression.items.every(item => this.isJsonDefaultExpression(item));
+            case 'RecordExpression': return expression.entries.every(item => this.isJsonDefaultExpression(item.value));
+            case 'CallExpression': return expression.callee.kind === 'IdentifierExpression' && ['Some', 'Ok', 'Err'].includes(expression.callee.name) && expression.arguments.every(item => this.isJsonDefaultExpression(item));
+            default: return false;
+        }
+    }
+    checkDerives(derives, span, typeName) {
+        const seen = new Set();
+        for (const derive of derives) {
+            if (seen.has(derive))
+                this.diagnostics.error('L2060', `Duplicate derive ${derive} on ${typeName}`, span);
+            seen.add(derive);
+            if (!['Eq', 'Hash', 'Debug', 'Json'].includes(derive))
+                this.diagnostics.error('L2003', `Unknown derive ${derive} on ${typeName}`, span);
+        }
+        const typeId = this.#namedTypes.get(typeName);
+        const type = typeId === undefined ? undefined : this.arena.get(typeId);
+        if (type?.kind !== 'named')
+            return;
+        const components = type.fields === undefined ? [...(type.variants?.values() ?? [])].flat() : [...type.fields.values()];
+        if (derives.includes('Eq'))
+            for (const component of components)
+                if (!this.supportsDerivedEq(component, typeId)) {
+                    this.diagnostics.error('L2061', `${typeName} cannot derive Eq because ${this.arena.display(component)} does not support derived equality`, span);
+                    break;
+                }
+        if (derives.includes('Hash')) {
+            if (!derives.includes('Eq'))
+                this.diagnostics.error('L2092', `${typeName} must derive Eq before Hash`, span);
+            for (const component of components)
+                if (!this.supportsHash(component)) {
+                    this.diagnostics.error('L2093', `${typeName} cannot derive Hash because ${this.arena.display(component)} is not hashable`, span);
+                    break;
+                }
+        }
+        if (derives.includes('Json'))
+            for (const component of components)
+                if (!this.supportsJson(component)) {
+                    this.diagnostics.error('L2062', `${typeName} cannot derive Json because ${this.arena.display(component)} is not JSON-compatible`, span);
+                    break;
+                }
+    }
+    checkBlock(block, parent) {
+        const scope = new Scope(parent);
+        for (const statement of block.statements)
+            this.checkStatement(statement, scope);
+    }
+    checkStatement(statement, scope) {
+        switch (statement.kind) {
+            case 'LetStatement': {
+                const annotated = statement.annotation === undefined ? undefined : this.resolveTypeReference(statement.annotation, new Map());
+                const valueType = this.checkExpression(statement.value, scope, annotated);
+                const expected = annotated ?? valueType;
+                if (!this.isAssignable(valueType, expected))
+                    this.typeMismatch(valueType, expected, statement.value.span);
+                const symbol = this.#factory.create(statement.name, 'variable', expected, statement.span, { mutable: statement.mutable, declaration: statement });
+                if (!scope.define(symbol))
+                    this.diagnostics.error('L1007', `Local name ${statement.name} shadows an existing name`, statement.span);
+                else {
+                    statement.symbolId = symbol.id;
+                    statement.inferredTypeId = expected;
+                    this.#symbols.set(symbol.id, symbol);
+                }
+                break;
+            }
+            case 'ReturnStatement': {
+                if (this.#currentFunction?.declaration.kind === 'ComponentDeclaration') {
+                    if (statement.value?.kind === 'ViewExpression')
+                        this.checkViewExpression(statement.value, scope);
+                    else {
+                        if (statement.value !== undefined)
+                            this.checkExpression(statement.value, scope);
+                        this.diagnostics.error('L4303', 'Component returns must directly return view', statement.span);
+                    }
+                    break;
+                }
+                const typeId = statement.value === undefined ? this.arena.unit : this.checkExpression(statement.value, scope, this.#currentFunction?.returnType);
+                this.#currentFunction?.returnTypes.push(typeId);
+                if (this.#currentFunction?.returnType !== undefined && !this.isAssignable(typeId, this.#currentFunction.returnType))
+                    this.typeMismatch(typeId, this.#currentFunction.returnType, statement.span);
+                break;
+            }
+            case 'IfStatement':
+                this.requireBool(this.checkExpression(statement.condition, scope, this.arena.bool), statement.condition.span);
+                this.checkBlock(statement.thenBlock, scope);
+                if (statement.elseBranch?.kind === 'BlockStatement')
+                    this.checkBlock(statement.elseBranch, scope);
+                else if (statement.elseBranch !== undefined)
+                    this.checkStatement(statement.elseBranch, scope);
+                break;
+            case 'ForStatement': {
+                const iterableType = this.arena.get(this.checkExpression(statement.iterable, scope));
+                let itemType = this.arena.error;
+                if (iterableType.kind === 'list' || iterableType.kind === 'set')
+                    itemType = iterableType.element;
+                else if (iterableType.kind === 'map')
+                    itemType = this.arena.tuple([iterableType.key, iterableType.value]);
+                else if (iterableType.kind === 'primitive' && iterableType.name === 'String')
+                    itemType = this.arena.string;
+                else
+                    this.diagnostics.error('L2004', 'for requires an iterable List, Set, Map, or String value', statement.iterable.span);
+                const child = new Scope(scope);
+                const symbol = this.#factory.create(statement.name, 'variable', itemType, statement.span, { declaration: statement });
+                if (!child.define(symbol))
+                    this.diagnostics.error('L1008', `Loop variable ${statement.name} shadows an existing name`, statement.span);
+                else {
+                    statement.symbolId = symbol.id;
+                    this.#symbols.set(symbol.id, symbol);
+                }
+                this.#loopDepth++;
+                this.checkBlock(statement.body, child);
+                this.#loopDepth--;
+                break;
+            }
+            case 'WhileStatement':
+                this.requireBool(this.checkExpression(statement.condition, scope, this.arena.bool), statement.condition.span);
+                this.#loopDepth++;
+                this.checkBlock(statement.body, scope);
+                this.#loopDepth--;
+                break;
+            case 'BreakStatement':
+                if (this.#loopDepth === 0)
+                    this.diagnostics.error('L2095', 'break can be used only inside a loop', statement.span);
+                break;
+            case 'ContinueStatement':
+                if (this.#loopDepth === 0)
+                    this.diagnostics.error('L2096', 'continue can be used only inside a loop', statement.span);
+                break;
+            case 'DiscardStatement':
+                this.checkExpression(statement.expression, scope);
+                break;
+            case 'AssignmentStatement': {
+                if (statement.invalidTarget !== undefined) {
+                    this.checkExpression(statement.invalidTarget, scope);
+                    this.checkExpression(statement.value, scope);
+                    this.diagnostics.error('L2118', 'Invalid assignment target; expected a mutable name, member, or index target', statement.span);
+                    break;
+                }
+                const target = scope.lookup(statement.name);
+                if (target === undefined)
+                    this.diagnostics.error('L1009', `Unknown name ${statement.name}`, statement.span);
+                else if (!target.mutable)
+                    this.diagnostics.error('L2010', `Cannot assign to immutable name ${statement.name}`, statement.span);
+                else {
+                    statement.targetSymbolId = target.id;
+                    const valueType = this.checkExpression(statement.value, scope, target.typeId);
+                    if (this.containsOpenEffect(valueType))
+                        this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be assigned', statement.span);
+                    if (!this.isAssignable(valueType, target.typeId))
+                        this.typeMismatch(valueType, target.typeId, statement.value.span);
+                }
+                break;
+            }
+            case 'MemberAssignmentStatement': {
+                const targetTypeId = this.checkExpression(statement.target, scope);
+                const targetType = this.arena.get(targetTypeId);
+                if (targetType.kind !== 'foreign') {
+                    this.checkExpression(statement.value, scope);
+                    this.diagnostics.error('L2119', 'Member assignment requires a proven writable facet', statement.span);
+                    break;
+                }
+                this.requireEffects(['JavaScript'], statement.span);
+                const prepared = this.prepareInteropValue(statement.value, scope);
+                const provider = this.currentInteropProvider(targetType.snapshot);
+                let resolution;
+                if (provider !== undefined && prepared.argument.kind !== 'unknown' && provider.resolveWriteUsage !== undefined) {
+                    try {
+                        resolution = provider.resolveWriteUsage(targetType.ref, { kind: 'property', property: statement.field, value: prepared.argument });
+                    }
+                    catch {
+                        resolution = undefined;
+                    }
+                }
+                const objectEvidence = provider === undefined ? undefined : this.validateWriteEvidence(resolution, prepared, provider);
+                if (objectEvidence === undefined) {
+                    this.diagnostics.error('L2119', 'Member assignment requires a proven writable facet', statement.span);
+                    break;
+                }
+                if (objectEvidence !== null)
+                    this.commitContextualObjects([objectEvidence]);
+                statement.foreignWrite = true;
+                this.#interopUsages.push({ kind: 'write-property', nodeId: statement.id, span: statement.span, foreignType: targetType.snapshot, property: statement.field });
+                break;
+            }
+            case 'IndexAssignmentStatement': {
+                const targetTypeId = this.checkExpression(statement.target, scope);
+                const indexTypeId = this.checkExpression(statement.index, scope);
+                const targetType = this.arena.get(targetTypeId);
+                if (targetType.kind !== 'foreign') {
+                    this.checkExpression(statement.value, scope);
+                    this.diagnostics.error('L2120', 'Index assignment requires a proven writable facet', statement.span);
+                    break;
+                }
+                this.requireEffects(['JavaScript'], statement.span);
+                const provider = this.currentInteropProvider(targetType.snapshot);
+                const index = this.interopArgumentType(indexTypeId, statement.index, statement.index.span);
+                const prepared = this.prepareInteropValue(statement.value, scope);
+                let resolution;
+                if (provider !== undefined && index.kind !== 'unknown' && prepared.argument.kind !== 'unknown' && provider.resolveWriteUsage !== undefined) {
+                    try {
+                        resolution = provider.resolveWriteUsage(targetType.ref, { kind: 'index', index, value: prepared.argument });
+                    }
+                    catch {
+                        resolution = undefined;
+                    }
+                }
+                const objectEvidence = provider === undefined ? undefined : this.validateWriteEvidence(resolution, prepared, provider);
+                if (objectEvidence === undefined) {
+                    this.diagnostics.error('L2120', 'Index assignment requires a proven writable facet', statement.span);
+                    break;
+                }
+                if (objectEvidence !== null)
+                    this.commitContextualObjects([objectEvidence]);
+                statement.foreignWrite = true;
+                this.#interopUsages.push({ kind: 'write-index', nodeId: statement.id, span: statement.span, foreignType: targetType.snapshot });
+                break;
+            }
+            case 'DeferStatement': {
+                if (this.#currentFunction === undefined)
+                    this.diagnostics.error('L2070', 'defer can be used only inside a function or test', statement.span);
+                const deferredType = this.checkExpression(statement.expression, scope);
+                if (!this.arena.equals(deferredType, this.arena.unit) && !this.arena.equals(deferredType, this.arena.never))
+                    this.diagnostics.error('L2071', `defer expression must produce Unit, received ${this.arena.display(deferredType)}`, statement.expression.span);
+                break;
+            }
+            case 'ExpressionStatement': {
+                const result = this.checkExpression(statement.expression, scope);
+                if (this.isMustUse(result))
+                    this.diagnostics.error('L2097', `Value of type ${this.arena.display(result)} must be used; bind it, return it, await it, handle it, or write discard`, statement.span);
+                break;
+            }
+        }
+    }
+    checkExpression(expression, scope, expected) {
+        let typeId;
+        switch (expression.kind) {
+            case 'LiteralExpression':
+                typeId = this.literalType(expression);
+                break;
+            case 'IdentifierExpression': {
+                if (expression.name === 'None' && expected !== undefined && this.arena.get(expected).kind === 'option') {
+                    expression.inferredTypeId = expected;
+                    return expected;
+                }
+                const symbol = scope.lookup(expression.name);
+                if (symbol === undefined) {
+                    this.diagnostics.error('L1010', `Unknown name ${expression.name}`, expression.span);
+                    typeId = this.arena.error;
+                }
+                else {
+                    expression.symbolId = symbol.id;
+                    if (symbol.kind === 'component') {
+                        this.diagnostics.error('L4305', `Component ${expression.name} cannot be used as an ordinary Virune value; use it as a View tag`, expression.span);
+                        typeId = this.arena.error;
+                        break;
+                    }
+                    typeId = symbol.typeId;
+                    if (symbol.typeOnly)
+                        this.diagnostics.error('L1012', `Type-only import ${expression.name} cannot be used as a value`, expression.span);
+                    if (this.#currentFunction?.declaration.kind === 'LambdaExpression' && this.containsOpenEffect(symbol.typeId) && symbol.declaration !== this.#currentFunction.declaration)
+                        this.diagnostics.error('L2113', 'uses * callbacks are non-escaping and cannot be captured by lambdas', expression.span);
+                    if (expected !== undefined && symbol.kind === 'variant') {
+                        const substitutions = new Map();
+                        this.unify(typeId, expected, substitutions);
+                        typeId = this.substitute(typeId, substitutions);
+                    }
+                }
+                break;
+            }
+            case 'WildcardExpression':
+                this.diagnostics.error('L2011', 'Wildcard can only be used in patterns or pipeline placeholders', expression.span);
+                typeId = this.arena.error;
+                break;
+            case 'CallExpression':
+                typeId = this.checkCall(expression, scope, expected);
+                break;
+            case 'FieldExpression':
+                typeId = this.checkField(expression, scope);
+                break;
+            case 'IndexExpression':
+                typeId = this.checkForeignIndex(expression, scope);
+                break;
+            case 'BinaryExpression':
+                typeId = this.checkBinary(expression, scope);
+                break;
+            case 'UnaryExpression':
+                typeId = this.checkUnary(expression, scope);
+                break;
+            case 'PipelineExpression':
+                typeId = this.checkPipeline(expression, scope);
+                break;
+            case 'TryExpression':
+                typeId = this.checkTry(expression, scope);
+                break;
+            case 'AwaitExpression':
+                typeId = this.checkAwait(expression, scope);
+                break;
+            case 'RecordExpression':
+                typeId = this.checkRecord(expression, scope, expected);
+                break;
+            case 'RecordUpdateExpression':
+                typeId = this.checkRecordUpdate(expression, scope);
+                break;
+            case 'ContextualAggregateExpression':
+                typeId = this.checkContextualAggregate(expression, scope, expected);
+                break;
+            case 'ListExpression':
+                typeId = this.checkList(expression, scope, expected);
+                break;
+            case 'TupleExpression':
+                typeId = this.arena.tuple(expression.items.map(item => this.checkExpression(item, scope)));
+                break;
+            case 'ConditionalExpression': {
+                this.requireBool(this.checkExpression(expression.condition, scope, this.arena.bool), expression.condition.span);
+                const left = this.checkExpression(expression.thenExpression, scope, expected);
+                const right = this.checkExpression(expression.elseExpression, scope, expected);
+                typeId = this.commonType([left, right], expression.span);
+                break;
+            }
+            case 'MatchExpression':
+                typeId = this.checkMatch(expression, scope, expected);
+                break;
+            case 'LambdaExpression':
+                typeId = this.checkLambda(expression, scope, expected);
+                break;
+            case 'ParallelExpression':
+                typeId = this.checkParallel(expression, scope);
+                break;
+            case 'ViewExpression':
+                this.diagnostics.error('L4300', 'view is compiler-controlled and can be used only as a direct component return', expression.span);
+                typeId = this.arena.error;
+                break;
+        }
+        typeId = this.applyExpectedForeignBridge(expression, typeId, expected);
+        expression.inferredTypeId = typeId;
+        return typeId;
+    }
+    checkViewExpression(expression, scope) {
+        this.checkViewBlock(expression.body, scope);
+    }
+    checkViewBlock(block, scope, insideRepetition = false) {
+        for (const child of block.children) {
+            switch (child.kind) {
+                case 'ViewTextChild': break;
+                case 'ViewExpressionChild':
+                    this.checkExpression(child.expression, scope);
+                    break;
+                case 'ViewChildrenSlot':
+                    if (insideRepetition) {
+                        this.diagnostics.error('L4311', 'children cannot appear inside View repetition', child.span);
+                        break;
+                    }
+                    this.#currentComponentChildrenSlots++;
+                    if (this.#currentComponentChildrenSlots > 1)
+                        this.diagnostics.error('L4306', 'A component may contain at most one children slot', child.span);
+                    break;
+                case 'ViewElement': {
+                    const root = child.tag[0];
+                    const native = child.tag.length === 1 && root !== undefined && this.globalScope.lookup(root)?.kind === 'component';
+                    const viewCallbackIndexes = [];
+                    for (let propertyIndex = 0; propertyIndex < child.properties.length; propertyIndex += 1) {
+                        const property = child.properties[propertyIndex];
+                        if (!native && this.isFrontendViewCallback(property.value)) {
+                            viewCallbackIndexes.push(propertyIndex);
+                            continue;
+                        }
+                        const typeId = this.checkExpression(property.value, scope);
+                        if (native)
+                            continue;
+                        const boundary = this.nativeCallableBoundary(typeId, property.value, true);
+                        if (boundary === undefined || boundary.version !== 'virune-callable-shim/v1' || boundary.parameters.includes('Int'))
+                            continue;
+                        this.requireEffects(boundary.effects, property.value.span);
+                        this.#frontendCallableProjections.push({ viewElementNodeId: child.id, propertyIndex, property: property.name, descriptor: boundary });
+                    }
+                    for (const propertyIndex of viewCallbackIndexes)
+                        this.checkFrontendViewCallback(child, propertyIndex, scope);
+                    if (child.children !== undefined)
+                        this.checkViewBlock(child.children, scope, insideRepetition);
+                    break;
+                }
+                case 'ViewConditional':
+                    this.requireBool(this.checkExpression(child.condition, scope, this.arena.bool), child.condition.span);
+                    this.checkViewBlock(child.thenBlock, scope, insideRepetition);
+                    if (child.elseBranch?.kind === 'ViewBlock')
+                        this.checkViewBlock(child.elseBranch, scope, insideRepetition);
+                    else if (child.elseBranch !== undefined)
+                        this.checkViewConditional(child.elseBranch, scope, insideRepetition);
+                    break;
+                case 'ViewRepetition':
+                    this.checkViewRepetition(child, scope);
+                    break;
+            }
+        }
+    }
+    isFrontendViewCallback(expression) {
+        return expression.kind === 'LambdaExpression' && expression.expressionBody && expression.body.kind === 'ViewExpression';
+    }
+    frontendExternalViewTag(tag) {
+        const root = tag[0];
+        if (root === undefined)
+            return undefined;
+        const symbol = this.globalScope.lookup(root);
+        if (symbol === undefined)
+            return undefined;
+        let type = this.arena.get(symbol.typeId);
+        if (type.kind !== 'foreign')
+            return undefined;
+        const provider = this.currentInteropProvider(type.snapshot);
+        if (provider === undefined)
+            return undefined;
+        let snapshot = type.snapshot;
+        for (const property of tag.slice(1)) {
+            let next;
+            try {
+                next = provider.getProperty(snapshot.ref, property);
+            }
+            catch {
+                next = undefined;
+            }
+            if (!this.isCurrentForeignSnapshot(next, provider, false))
+                return undefined;
+            snapshot = next;
+            type = this.arena.get(this.arena.foreign(snapshot));
+        }
+        return { ref: snapshot.ref, provider };
+    }
+    frontendJsxPropertyArgument(element, propertyIndex) {
+        const property = element.properties[propertyIndex];
+        if (property === undefined)
+            return undefined;
+        if (this.isFrontendViewCallback(property.value)) {
+            return { kind: 'contextual-callable', parameterCount: property.value.parameters.length, async: property.value.async };
+        }
+        const projection = this.#frontendCallableProjections.find(item => item.viewElementNodeId === element.id && item.propertyIndex === propertyIndex && item.property === property.name);
+        if (projection?.descriptor !== undefined) {
+            return {
+                kind: 'native-callable',
+                callable: {
+                    parameters: projection.descriptor.parameters,
+                    result: projection.descriptor.result,
+                    async: projection.descriptor.async,
+                },
+            };
+        }
+        const typeId = property.value.inferredTypeId;
+        if (typeId === undefined)
+            return undefined;
+        const type = this.arena.get(typeId);
+        if (type.kind === 'foreign') {
+            const provider = this.currentInteropProvider(type.snapshot);
+            return provider !== undefined && this.isCurrentForeignSnapshot(type.snapshot, provider, false)
+                ? { kind: 'foreign', type: type.ref }
+                : undefined;
+        }
+        if (type.kind !== 'primitive' || !['Bool', 'Int', 'Float', 'BigInt', 'String', 'Unit'].includes(type.name))
+            return undefined;
+        const primitive = type.name;
+        const literal = this.interopLiteralValue(property.value);
+        return literal === undefined ? { kind: 'native-primitive', primitive } : { kind: 'native-primitive', primitive, literal };
+    }
+    checkFrontendViewCallback(element, propertyIndex, scope) {
+        const property = element.properties[propertyIndex];
+        if (property === undefined || !this.isFrontendViewCallback(property.value))
+            return;
+        const lambda = property.value;
+        const root = element.tag[0];
+        const rootSymbol = root === undefined ? undefined : this.globalScope.lookup(root);
+        const rootType = rootSymbol === undefined ? undefined : this.arena.get(rootSymbol.typeId);
+        if (rootType?.kind !== 'foreign') {
+            this.checkExpression(lambda, scope);
+            return;
+        }
+        if (lambda.async) {
+            this.diagnostics.error('L4300', 'View-producing External JSX callbacks must be synchronous', lambda.span);
+            return;
+        }
+        if (lambda.parameters.some(parameter => parameter.annotation !== undefined)) {
+            this.diagnostics.error('L4300', 'View-producing External JSX callback parameters must use TypeScript contextual typing', lambda.span);
+            return;
+        }
+        if (lambda.returnType !== undefined) {
+            this.diagnostics.error('L4300', 'View-producing External JSX callbacks cannot declare a Virune return type', lambda.returnType.span);
+            return;
+        }
+        const target = this.frontendExternalViewTag(element.tag);
+        const resolver = target?.provider.resolveJsxCallbackUsage;
+        if (target === undefined || resolver === undefined) {
+            this.diagnostics.error('L4308', `Cannot resolve contextual View callback for External JSX property ${property.name}`, property.span);
+            return;
+        }
+        const properties = [];
+        for (let index = 0; index < element.properties.length; index += 1) {
+            const item = element.properties[index];
+            const value = this.frontendJsxPropertyArgument(element, index);
+            if (value === undefined) {
+                this.diagnostics.error('L4308', `Cannot prove sibling JSX property ${item.name} while resolving contextual View callback ${property.name}`, item.span);
+                return;
+            }
+            properties.push({ property: item.name, value });
+        }
+        let resolution;
+        try {
+            resolution = resolver.call(target.provider, target.ref, {
+                properties: Object.freeze(properties),
+                callbackIndex: propertyIndex,
+                parameterCount: lambda.parameters.length,
+                async: false,
+            });
+        }
+        catch {
+            resolution = undefined;
+        }
+        if (!isRecord(resolution) || !hasExactEnumerableKeys(resolution, ['parameters']) || !Array.isArray(resolution.parameters) || resolution.parameters.length !== lambda.parameters.length) {
+            this.diagnostics.error('L4308', `Cannot prove contextual View callback parameters for External JSX property ${property.name}`, property.span);
+            return;
+        }
+        const parameterTypes = [];
+        for (const parameter of resolution.parameters) {
+            if (!this.isCurrentForeignSnapshot(parameter, target.provider, false) || parameter.category !== 'object') {
+                this.diagnostics.error('L4308', `Contextual View callback property ${property.name} requires concrete External object parameter evidence`, property.span);
+                return;
+            }
+            parameterTypes.push(this.arena.foreign(parameter));
+        }
+        this.checkFrontendViewLambda(lambda, scope, parameterTypes);
+        const effects = Object.freeze([...new Set(lambda.effects)].sort(compareText));
+        this.requireEffects(effects, lambda.span);
+        this.#frontendCallableProjections.push({
+            viewElementNodeId: element.id,
+            propertyIndex,
+            property: property.name,
+            viewCallback: { parameterCount: lambda.parameters.length, effects },
+        });
+    }
+    checkFrontendViewLambda(expression, scope, contextualParameters) {
+        const child = new Scope(scope);
+        expression.parameters.forEach((parameter, index) => {
+            const typeId = contextualParameters[index] ?? this.arena.error;
+            const symbol = this.#factory.create(parameter.name, 'parameter', typeId, parameter.span, { declaration: expression });
+            if (!child.define(symbol))
+                this.diagnostics.error('L1012', `Lambda parameter ${parameter.name} shadows an existing name`, parameter.span);
+            else {
+                parameter.symbolId = symbol.id;
+                this.#symbols.set(symbol.id, symbol);
+            }
+        });
+        this.validateEffects(expression.effects, expression.span);
+        const previous = this.#currentFunction;
+        this.#currentFunction = {
+            declaration: expression,
+            scope: child,
+            async: false,
+            returnTypes: [],
+            typeParameters: new Map(),
+            effects: new Set(expression.effects),
+        };
+        this.checkViewExpression(expression.body, child);
+        this.#currentFunction = previous;
+    }
+    checkViewConditional(conditional, scope, insideRepetition = false) {
+        this.requireBool(this.checkExpression(conditional.condition, scope, this.arena.bool), conditional.condition.span);
+        this.checkViewBlock(conditional.thenBlock, scope, insideRepetition);
+        if (conditional.elseBranch?.kind === 'ViewBlock')
+            this.checkViewBlock(conditional.elseBranch, scope, insideRepetition);
+        else if (conditional.elseBranch !== undefined)
+            this.checkViewConditional(conditional.elseBranch, scope, insideRepetition);
+    }
+    checkViewRepetition(repetition, scope) {
+        delete repetition.checkedEvidence;
+        const sourceTypeId = this.checkExpression(repetition.source, scope);
+        const sourceType = this.arena.get(sourceTypeId);
+        let sourceKind;
+        let itemType = this.arena.error;
+        if (sourceType.kind === 'list') {
+            sourceKind = 'native-list';
+            itemType = sourceType.element;
+        }
+        else if (sourceType.kind === 'foreign' && sourceType.snapshot.category === 'array') {
+            const provider = this.currentInteropProvider(sourceType.snapshot);
+            let element;
+            if (provider?.resolveArrayElement !== undefined) {
+                try {
+                    element = provider.resolveArrayElement(sourceType.ref);
+                }
+                catch {
+                    element = undefined;
+                }
+            }
+            if (provider !== undefined && this.isCurrentForeignSnapshot(element, provider, false)) {
+                this.requireEffects(['JavaScript'], repetition.span);
+                sourceKind = 'external-array';
+                itemType = this.arena.foreign(element);
+            }
+        }
+        if (sourceKind === undefined)
+            this.diagnostics.error('L4310', 'View repetition requires a native List or proven External Array source', repetition.source.span);
+        const childScope = new Scope(scope);
+        const item = this.#factory.create(repetition.itemName, 'variable', itemType, repetition.span, { declaration: repetition });
+        let itemSymbolId;
+        if (!childScope.define(item))
+            this.diagnostics.error('L1008', `View repetition item ${repetition.itemName} shadows an existing name`, repetition.span);
+        else {
+            itemSymbolId = item.id;
+            this.#symbols.set(item.id, item);
+        }
+        let indexSymbolId;
+        if (repetition.indexName !== undefined) {
+            const index = this.#factory.create(repetition.indexName, 'variable', this.arena.int, repetition.span, { declaration: repetition });
+            if (!childScope.define(index))
+                this.diagnostics.error('L1008', `View repetition index ${repetition.indexName} shadows an existing name`, repetition.span);
+            else {
+                indexSymbolId = index.id;
+                this.#symbols.set(index.id, index);
+            }
+        }
+        const identityTypeId = this.checkExpression(repetition.identity, childScope);
+        const identityType = this.arena.get(identityTypeId);
+        const identityValid = identityTypeId !== this.arena.error && identityType.kind === 'primitive' && (identityType.name === 'String' || identityType.name === 'Int');
+        if (identityTypeId !== this.arena.error && !identityValid)
+            this.diagnostics.error('L4312', `View repetition identity must be String or Int, received ${this.arena.display(identityTypeId)}`, repetition.identity.span);
+        if (identityValid && sourceKind !== undefined && itemSymbolId !== undefined && (repetition.indexName === undefined || indexSymbolId !== undefined)) {
+            repetition.checkedEvidence = { sourceKind, itemSymbolId, indexSymbolId };
+        }
+        this.checkViewBlock(repetition.body, childScope, true);
+    }
+    checkContextualAggregate(expression, scope, expected) {
+        const prepared = this.prepareContextualObject(expression, scope);
+        const expectedType = expected === undefined ? undefined : this.arena.get(expected);
+        if (expected !== undefined && expectedType?.kind === 'foreign') {
+            const provider = this.currentInteropProvider(expectedType.snapshot);
+            let resolution;
+            if (provider?.resolveObjectUsage !== undefined) {
+                try {
+                    resolution = provider.resolveObjectUsage(expectedType.ref, prepared.usage);
+                }
+                catch {
+                    resolution = undefined;
+                }
+            }
+            const validated = provider === undefined ? undefined : this.validateContextualObjectEvidence(resolution, prepared, provider);
+            if (validated !== undefined) {
+                this.commitContextualObjects([validated]);
+                return expected;
+            }
+        }
+        this.diagnostics.error('L2122', 'Contextual aggregate requires a supported expected aggregate facet', expression.span);
+        return this.arena.error;
+    }
+    checkForeignIndex(expression, scope) {
+        const targetTypeId = this.checkExpression(expression.target, scope);
+        const indexTypeId = this.checkExpression(expression.index, scope);
+        const targetType = this.arena.get(targetTypeId);
+        if (targetType.kind !== 'foreign') {
+            this.diagnostics.error('L2121', 'Index access requires a proven index facet', expression.span);
+            return this.arena.error;
+        }
+        this.requireEffects(['JavaScript'], expression.span);
+        const provider = this.currentInteropProvider(targetType.snapshot);
+        const index = this.interopArgumentType(indexTypeId, expression.index, expression.index.span);
+        let resolution;
+        if (provider !== undefined && index.kind !== 'unknown' && provider.resolveIndexUsage !== undefined) {
+            try {
+                resolution = provider.resolveIndexUsage(targetType.ref, { index });
+            }
+            catch {
+                resolution = undefined;
+            }
+        }
+        if (provider === undefined || !this.isCurrentForeignSnapshot(resolution?.result, provider, false)) {
+            this.diagnostics.error('L2121', 'Index access requires a proven index facet', expression.span);
+            return this.arena.error;
+        }
+        expression.foreignIndex = true;
+        this.#interopUsages.push({ kind: 'index', nodeId: expression.id, span: expression.span, foreignType: resolution.result });
+        return this.arena.foreign(resolution.result);
+    }
+    checkForeignCall(expression, scope, callee) {
+        this.requireEffects(['JavaScript'], expression.span);
+        if (expression.typeArguments.length > 0)
+            this.diagnostics.error('L4203', 'Explicit Virune type arguments are not supported for JavaScript calls; use a TypeScript interop adapter', expression.span);
+        let preparedArguments = expression.arguments.map((argument, index) => this.prepareForeignCallValue(argument, scope, index === expression.arguments.length - 1));
+        let interopArguments = preparedArguments.map(argument => argument.argument);
+        let callableBoundaries = preparedArguments.map(argument => argument.boundary);
+        let target = { kind: 'value' };
+        if (expression.callee.kind === 'FieldExpression') {
+            const receiverTypeId = expression.callee.target.inferredTypeId;
+            const receiver = receiverTypeId === undefined ? undefined : this.arena.get(receiverTypeId);
+            if (receiver?.kind === 'foreign')
+                target = { kind: 'member', receiver: receiver.ref, property: expression.callee.field };
+        }
+        else if (expression.callee.kind === 'IndexExpression') {
+            const receiverTypeId = expression.callee.target.inferredTypeId;
+            const indexTypeId = expression.callee.index.inferredTypeId;
+            const receiver = receiverTypeId === undefined ? undefined : this.arena.get(receiverTypeId);
+            if (receiver?.kind === 'foreign' && indexTypeId !== undefined) {
+                const index = this.interopArgumentType(indexTypeId, expression.callee.index, expression.callee.index.span);
+                if (index.kind !== 'unknown')
+                    target = { kind: 'indexed-member', receiver: receiver.ref, index };
+            }
+        }
+        const provider = this.currentInteropProvider(callee);
+        if (provider === undefined) {
+            this.diagnostics.error('L4204', `Cannot resolve JavaScript call for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+            return this.arena.error;
+        }
+        let usage = { target, arguments: interopArguments };
+        if (interopArguments.some(argument => this.interopArgumentHasContextualCallable(argument))) {
+            if (provider.resolveCallUsage === undefined) {
+                this.diagnostics.error('L4204', `Cannot contextually resolve JavaScript callback for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                return this.arena.error;
+            }
+            let contextualResolution;
+            try {
+                contextualResolution = provider.resolveCallUsage(callee.ref, usage);
+            }
+            catch {
+                contextualResolution = undefined;
+            }
+            if (contextualResolution === undefined || !this.isValidForeignInvocationResolution(contextualResolution, provider, target, false, true)) {
+                this.diagnostics.error('L4204', `Cannot resolve contextual JavaScript callback for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                return this.arena.error;
+            }
+            const contextualEvidence = this.validateContextualCallableArgumentEvidence(contextualResolution.contextualCallableArguments, interopArguments, provider);
+            if (contextualEvidence === undefined) {
+                this.diagnostics.error('L4204', `Cannot prove contextual JavaScript callback for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                return this.arena.error;
+            }
+            const evidenceByIndex = new Map(contextualEvidence.map(evidence => [evidence.index, evidence]));
+            const finalized = [];
+            for (let index = 0; index < preparedArguments.length; index++) {
+                const prepared = preparedArguments[index];
+                if (prepared.argument.kind !== 'contextual-callable') {
+                    finalized.push(prepared);
+                    continue;
+                }
+                const argument = expression.arguments[index];
+                const evidence = evidenceByIndex.get(index);
+                if (argument?.kind !== 'LambdaExpression' || evidence === undefined) {
+                    this.diagnostics.error('L4204', `Cannot prove contextual JavaScript callback for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                    return this.arena.error;
+                }
+                const parameterTypes = evidence.target.parameters.map(parameter => this.contextualCallableTypeId(parameter, provider));
+                if (parameterTypes.some(parameter => parameter === undefined)) {
+                    this.diagnostics.error('L4204', `Cannot safely project contextual JavaScript callback parameters for ${callee.display}`, argument.span);
+                    return this.arena.error;
+                }
+                const typeId = this.checkLambda(argument, scope, undefined, parameterTypes);
+                argument.inferredTypeId = typeId;
+                const projection = this.externalInlineCallableProjection(typeId, argument);
+                if (projection === undefined) {
+                    this.diagnostics.error('L4206', `Contextually typed native callback ${this.arena.display(typeId)} cannot cross the generated JavaScript callable boundary`, argument.span);
+                    return this.arena.error;
+                }
+                finalized.push({ expression: argument, argument: { kind: 'native-callable', callable: projection.callable }, boundary: projection.boundary, point: prepared.point });
+            }
+            const finalizedObjects = this.finalizeContextualObjectArguments(contextualResolution.objectArguments, finalized, provider, scope);
+            if (finalizedObjects === undefined) {
+                this.diagnostics.error('L4204', `Cannot prove contextual JavaScript object callback for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                return this.arena.error;
+            }
+            preparedArguments = [...finalizedObjects];
+            interopArguments = preparedArguments.map(argument => argument.argument);
+            callableBoundaries = preparedArguments.map(argument => argument.boundary);
+            usage = { target, arguments: interopArguments };
+        }
+        let resolution;
+        let invocationKind = 'call';
+        const wholeUsageResolution = provider.resolveCallUsage !== undefined;
+        try {
+            resolution = wholeUsageResolution
+                ? provider.resolveCallUsage(callee.ref, usage)
+                : provider.resolveCall(callee.ref, interopArguments);
+        }
+        catch {
+            this.diagnostics.error('L4204', `Cannot resolve JavaScript call for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+            return this.arena.error;
+        }
+        if (resolution !== undefined) {
+            if (!this.isValidForeignInvocationResolution(resolution, provider, usage.target, false, wholeUsageResolution)) {
+                this.diagnostics.error('L4204', `Cannot prove JavaScript call for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                return this.arena.error;
+            }
+        }
+        else if (provider.resolveConstructUsage !== undefined) {
+            let constructResolution;
+            try {
+                constructResolution = provider.resolveConstructUsage(callee.ref, usage);
+            }
+            catch {
+                constructResolution = undefined;
+            }
+            if (constructResolution !== undefined) {
+                if (!this.isValidForeignInvocationResolution(constructResolution, provider, usage.target, true, true)) {
+                    this.diagnostics.error('L4204', `Cannot prove JavaScript construct for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                    return this.arena.error;
+                }
+                resolution = constructResolution;
+                invocationKind = 'construct';
+            }
+        }
+        if (resolution === undefined) {
+            this.diagnostics.error('L4204', `Cannot resolve JavaScript call or construct for ${callee.display}; use a TypeScript interop adapter`, expression.span);
+            return this.arena.error;
+        }
+        if (invocationKind === 'construct' && expression.arguments.some((argument, index) => argument.kind === 'LambdaExpression' && argument.parameters.length === 0 && callableBoundaries[index]?.version === 'virune-callable-shim/v1')) {
+            this.diagnostics.error('L4204', `Zero-argument inline generated callbacks are not supported for JavaScript construct ${callee.display}; use a TypeScript interop adapter`, expression.span);
+            return this.arena.error;
+        }
+        if (resolution.contextualCallableArguments !== undefined && resolution.contextualCallableArguments.length !== 0) {
+            this.diagnostics.error('L4204', `Final JavaScript call retained provisional callback evidence for ${callee.display}`, expression.span);
+            return this.arena.error;
+        }
+        const callableEvidence = this.validateCallableArgumentEvidence(resolution.callableArguments, interopArguments, callableBoundaries, provider);
+        const objectEvidence = this.validateObjectArgumentEvidence(resolution.objectArguments, preparedArguments, provider);
+        if (callableEvidence === undefined || objectEvidence === undefined) {
+            this.diagnostics.error('L4204', `Cannot prove generated boundary for JavaScript ${invocationKind} ${callee.display}; use a TypeScript interop adapter`, expression.span);
+            return this.arena.error;
+        }
+        const pendingObjects = this.commitContextualObjects(objectEvidence);
+        const minimum = resolution.minimumArgumentCount ?? Math.max(0, resolution.parameterCount - resolution.optionalParameterCount);
+        if (expression.arguments.length < minimum || (!resolution.rest && expression.arguments.length > resolution.parameterCount))
+            this.diagnostics.error('L4205', `JavaScript ${invocationKind} expects ${minimum}${resolution.rest ? '+' : `..${resolution.parameterCount}`} arguments, received ${expression.arguments.length}`, expression.span);
+        for (const evidence of callableEvidence) {
+            const argument = expression.arguments.at(evidence.index);
+            const prepared = preparedArguments.at(evidence.index);
+            const boundary = callableBoundaries.at(evidence.index);
+            if (argument === undefined || prepared === undefined || boundary === undefined) {
+                this.diagnostics.error('L4204', `Cannot prove generated callback boundary for JavaScript ${invocationKind} ${callee.display}; use a TypeScript interop adapter`, expression.span);
+                return this.arena.error;
+            }
+            this.requireEffects(boundary.effects, argument.span);
+            if (boundary.version === 'virune-callable-shim/v3')
+                this.requireEffects(boundary.result.effects, argument.span);
+            this.#callableProjections.push({
+                callNodeId: expression.id,
+                argumentIndex: evidence.index,
+                nodeId: argument.id,
+                span: argument.span,
+                beforeUsageIndex: this.adjustedUsageIndex(prepared.point, pendingObjects),
+                descriptor: boundary,
+            });
+        }
+        if (invocationKind === 'call')
+            expression.foreignCall = true;
+        else
+            expression.foreignConstruct = true;
+        this.#interopUsages.push({ kind: invocationKind, nodeId: expression.id, span: expression.span, foreignType: resolution.result, receiverMode: invocationKind === 'call' ? resolution.receiverMode : 'none', ...(invocationKind === 'call' ? { mayReject: resolution.mayReject } : {}) });
+        return this.arena.foreign(resolution.result);
+    }
+    semanticPoint() {
+        return { usageIndex: this.#interopUsages.length, order: this.#semanticOrder++ };
+    }
+    interopArgumentHasContextualCallable(argument) {
+        return argument.kind === 'contextual-callable'
+            || argument.kind === 'contextual-object' && argument.object.entries.some(entry => this.interopArgumentHasContextualCallable(entry.value));
+    }
+    prepareForeignCallValue(expression, scope, allowContextual) {
+        if (allowContextual && expression.kind === 'LambdaExpression' && expression.parameters.length > 0 && expression.parameters.every(parameter => parameter.annotation === undefined)) {
+            return { expression, argument: { kind: 'contextual-callable', parameterCount: expression.parameters.length, async: expression.async }, point: this.semanticPoint() };
+        }
+        return this.prepareInteropValue(expression, scope, true);
+    }
+    prepareInteropValue(expression, scope, allowInlineZeroArgument = false) {
+        if (expression.kind === 'ContextualAggregateExpression') {
+            const object = this.prepareContextualObject(expression, scope);
+            return { expression, argument: { kind: 'contextual-object', object: object.usage }, object, point: this.semanticPoint() };
+        }
+        const typeId = this.checkExpression(expression, scope);
+        const boundary = this.nativeCallableBoundary(typeId, expression, allowInlineZeroArgument);
+        const callable = boundary === undefined
+            ? undefined
+            : boundary.version === 'virune-callable-shim/v3'
+                ? { parameters: boundary.parameters, result: { kind: 'callable', callable: { parameters: boundary.result.parameters, result: boundary.result.result, async: false } }, async: false }
+                : { parameters: boundary.parameters, result: boundary.result, async: boundary.async };
+        const argument = callable === undefined
+            ? this.interopArgumentType(typeId, expression, expression.span)
+            : { kind: 'native-callable', callable };
+        return { expression, argument, ...(boundary === undefined ? {} : { boundary }), point: this.semanticPoint() };
+    }
+    prepareContextualObjectValue(expression, scope) {
+        if (expression.kind === 'LambdaExpression' && expression.parameters.length > 0 && expression.parameters.every(parameter => parameter.annotation === undefined)) {
+            return { expression, argument: { kind: 'contextual-callable', parameterCount: expression.parameters.length, async: expression.async }, point: this.semanticPoint() };
+        }
+        return this.prepareInteropValue(expression, scope);
+    }
+    prepareContextualObject(expression, scope) {
+        const supplied = new Set();
+        const entries = [];
+        for (const entry of expression.entries) {
+            if (supplied.has(entry.name))
+                this.diagnostics.error('L2025', `Duplicate contextual aggregate field ${entry.name}`, entry.span);
+            supplied.add(entry.name);
+            entries.push(this.prepareContextualObjectValue(entry.value, scope));
+        }
+        return {
+            expression,
+            entries,
+            usage: { entries: expression.entries.map((entry, index) => ({ property: entry.name, value: entries[index].argument })) },
+            point: this.semanticPoint(),
+        };
+    }
+    finalizeContextualObjectArguments(raw, preparedArguments, provider, scope) {
+        const expected = preparedArguments.flatMap((argument, index) => argument.object === undefined ? [] : [{ index, object: argument.object }]);
+        if (expected.length === 0)
+            return raw === undefined || Array.isArray(raw) && raw.length === 0 ? Object.freeze([...preparedArguments]) : undefined;
+        if (!Array.isArray(raw) || raw.length !== expected.length)
+            return undefined;
+        const finalized = [...preparedArguments];
+        for (let position = 0; position < expected.length; position++) {
+            const item = raw[position];
+            const expectedItem = expected[position];
+            if (!isRecord(item) || !hasExactEnumerableKeys(item, ['index', 'object']) || item.index !== expectedItem.index)
+                return undefined;
+            const object = this.finalizeContextualObjectCallbacks(item.object, expectedItem.object, provider, scope);
+            const prepared = finalized[expectedItem.index];
+            if (object === undefined || prepared?.object === undefined)
+                return undefined;
+            finalized[expectedItem.index] = { ...prepared, argument: { kind: 'contextual-object', object: object.usage }, object };
+        }
+        return Object.freeze(finalized);
+    }
+    finalizeContextualObjectCallbacks(raw, prepared, provider, scope) {
+        if (!isRecord(raw) || !hasExactEnumerableKeys(raw, ['entries', 'result']) || !Array.isArray(raw.entries))
+            return undefined;
+        if (!this.isCurrentForeignSnapshot(raw.result, provider, false) || raw.entries.length !== prepared.entries.length)
+            return undefined;
+        const finalized = [];
+        for (let index = 0; index < prepared.entries.length; index++) {
+            const entry = raw.entries[index];
+            const preparedEntry = prepared.entries[index];
+            const property = prepared.expression.entries[index]?.name;
+            if (!isRecord(entry) || property === undefined || entry.index !== index || entry.property !== property)
+                return undefined;
+            if (preparedEntry.argument.kind === 'contextual-callable') {
+                if (!hasExactEnumerableKeys(entry, ['callable', 'index', 'property']))
+                    return undefined;
+                const callable = entry.callable;
+                if (!isRecord(callable) || !hasExactEnumerableKeys(callable, ['parameters', 'result']) || !Array.isArray(callable.parameters) || callable.parameters.length !== preparedEntry.argument.parameterCount)
+                    return undefined;
+                if (!callable.parameters.every(parameter => typeof parameter !== 'string' && parameter.category === 'object' && this.isCurrentForeignSnapshot(parameter, provider, false)))
+                    return undefined;
+                const contextualResult = canonicalContextualCallableResult(callable.result);
+                if (contextualResult?.kind !== 'deferred' || preparedEntry.expression.kind !== 'LambdaExpression')
+                    return undefined;
+                const parameterTypes = callable.parameters.map(parameter => this.contextualCallableTypeId(parameter, provider));
+                if (parameterTypes.some(parameter => parameter === undefined))
+                    return undefined;
+                const typeId = this.checkLambda(preparedEntry.expression, scope, undefined, parameterTypes);
+                preparedEntry.expression.inferredTypeId = typeId;
+                const projection = this.externalInlineCallableProjection(typeId, preparedEntry.expression);
+                if (projection === undefined)
+                    return undefined;
+                finalized.push({ expression: preparedEntry.expression, argument: { kind: 'native-callable', callable: projection.callable }, boundary: projection.boundary, point: preparedEntry.point });
+            }
+            else if (preparedEntry.object !== undefined) {
+                if (!hasExactEnumerableKeys(entry, ['index', 'object', 'property']))
+                    return undefined;
+                const object = this.finalizeContextualObjectCallbacks(entry.object, preparedEntry.object, provider, scope);
+                if (object === undefined)
+                    return undefined;
+                finalized.push({ ...preparedEntry, argument: { kind: 'contextual-object', object: object.usage }, object });
+            }
+            else {
+                const expectedKeys = preparedEntry.boundary === undefined ? ['index', 'property'] : ['callable', 'index', 'property'];
+                if (!hasExactEnumerableKeys(entry, expectedKeys))
+                    return undefined;
+                finalized.push(preparedEntry);
+            }
+        }
+        return {
+            expression: prepared.expression,
+            entries: Object.freeze(finalized),
+            usage: { entries: prepared.expression.entries.map((entry, index) => ({ property: entry.name, value: finalized[index].argument })) },
+            point: prepared.point,
+        };
+    }
+    validateObjectArgumentEvidence(raw, preparedArguments, provider) {
+        const expected = preparedArguments.flatMap((argument, index) => argument.object === undefined ? [] : [{ index, object: argument.object }]);
+        if (expected.length === 0)
+            return raw === undefined || Array.isArray(raw) && raw.length === 0 ? [] : undefined;
+        if (!Array.isArray(raw) || raw.length !== expected.length)
+            return undefined;
+        const validated = [];
+        for (let position = 0; position < expected.length; position++) {
+            const item = raw[position];
+            const expectedItem = expected[position];
+            if (!isRecord(item) || !hasExactEnumerableKeys(item, ['index', 'object']) || item.index !== expectedItem.index)
+                return undefined;
+            const object = this.validateContextualObjectEvidence(item.object, expectedItem.object, provider);
+            if (object === undefined)
+                return undefined;
+            validated.push(object);
+        }
+        return Object.freeze(validated);
+    }
+    validateContextualObjectEvidence(raw, prepared, provider) {
+        if (!isRecord(raw) || !hasExactEnumerableKeys(raw, ['entries', 'result']) || !Array.isArray(raw.entries))
+            return undefined;
+        const result = raw.result;
+        if (!this.isCurrentForeignSnapshot(result, provider, false) || raw.entries.length !== prepared.entries.length)
+            return undefined;
+        const nested = [];
+        const entries = [];
+        for (let index = 0; index < prepared.entries.length; index++) {
+            const entry = raw.entries[index];
+            const preparedEntry = prepared.entries[index];
+            const property = prepared.expression.entries[index]?.name;
+            if (!isRecord(entry) || property === undefined || entry.index !== index || entry.property !== property)
+                return undefined;
+            if (preparedEntry.boundary !== undefined) {
+                if (!hasExactEnumerableKeys(entry, ['callable', 'index', 'property']))
+                    return undefined;
+                const callable = entry.callable;
+                if (!isRecord(callable) || !hasExactEnumerableKeys(callable, ['parameters', 'result']) || !Array.isArray(callable.parameters))
+                    return undefined;
+                let parameters;
+                if (preparedEntry.boundary.version === 'virune-callable-shim/v1' || preparedEntry.boundary.version === 'virune-callable-shim/v3') {
+                    const primitives = [];
+                    for (const parameter of callable.parameters) {
+                        if (!isContextualCallablePrimitive(parameter))
+                            return undefined;
+                        primitives.push(parameter);
+                    }
+                    parameters = Object.freeze(primitives);
+                }
+                else {
+                    if (!callable.parameters.every(parameter => typeof parameter !== 'string' && parameter.category === 'object' && this.isCurrentForeignSnapshot(parameter, provider, false)))
+                        return undefined;
+                    parameters = Object.freeze(callable.parameters);
+                }
+                const contextualResult = canonicalContextualCallableResult(callable.result);
+                if (contextualResult === undefined || !this.callableBoundaryMatchesContext(preparedEntry.boundary, parameters, contextualResult))
+                    return undefined;
+                entries.push({ index, property, callable: Object.freeze({ parameters, result: contextualResult }) });
+                nested.push(undefined);
+            }
+            else if (preparedEntry.object !== undefined) {
+                if (!hasExactEnumerableKeys(entry, ['index', 'object', 'property']))
+                    return undefined;
+                const child = this.validateContextualObjectEvidence(entry.object, preparedEntry.object, provider);
+                if (child === undefined)
+                    return undefined;
+                entries.push({ index, property, object: child.resolution });
+                nested.push(child);
+            }
+            else {
+                if (!hasExactEnumerableKeys(entry, ['index', 'property']))
+                    return undefined;
+                entries.push({ index, property });
+                nested.push(undefined);
+            }
+        }
+        return { prepared, resolution: { result, entries: Object.freeze(entries) }, nested: Object.freeze(nested) };
+    }
+    validateWriteEvidence(raw, prepared, provider) {
+        if (!isRecord(raw) || raw.accepted !== true)
+            return undefined;
+        if (prepared.object === undefined)
+            return hasExactEnumerableKeys(raw, ['accepted']) ? null : undefined;
+        if (!hasExactEnumerableKeys(raw, ['accepted', 'objectValue']))
+            return undefined;
+        return this.validateContextualObjectEvidence(raw.objectValue, prepared.object, provider);
+    }
+    commitContextualObjects(validatedRoots) {
+        const pendingObjects = [];
+        const pendingProjections = [];
+        const collect = (validated) => {
+            for (let index = 0; index < validated.prepared.entries.length; index++) {
+                const nested = validated.nested[index];
+                if (nested !== undefined)
+                    collect(nested);
+                const preparedEntry = validated.prepared.entries[index];
+                const descriptor = preparedEntry.boundary;
+                const property = validated.prepared.expression.entries[index]?.name;
+                if (descriptor !== undefined && property !== undefined)
+                    pendingProjections.push({ prepared: preparedEntry, owner: validated.prepared, entryIndex: index, property, descriptor });
+            }
+            validated.prepared.expression.foreignObject = true;
+            validated.prepared.expression.inferredTypeId = this.arena.foreign(validated.resolution.result);
+            pendingObjects.push({ point: validated.prepared.point, usage: { kind: 'object', nodeId: validated.prepared.expression.id, span: validated.prepared.expression.span, foreignType: validated.resolution.result } });
+        };
+        for (const root of validatedRoots)
+            collect(root);
+        pendingObjects.sort((left, right) => compareSemanticPoint(left.point, right.point));
+        let inserted = 0;
+        for (const pending of pendingObjects) {
+            this.#interopUsages.splice(pending.point.usageIndex + inserted, 0, pending.usage);
+            inserted++;
+        }
+        for (const projection of pendingProjections) {
+            this.requireEffects(projection.descriptor.effects, projection.prepared.expression.span);
+            if (projection.descriptor.version === 'virune-callable-shim/v3')
+                this.requireEffects(projection.descriptor.result.effects, projection.prepared.expression.span);
+            this.#objectCallableProjections.push({
+                objectNodeId: projection.owner.expression.id,
+                entryIndex: projection.entryIndex,
+                property: projection.property,
+                beforeUsageIndex: this.adjustedUsageIndex(projection.prepared.point, pendingObjects),
+                descriptor: projection.descriptor,
+            });
+        }
+        return Object.freeze(pendingObjects);
+    }
+    adjustedUsageIndex(point, pendingObjects) {
+        let before = 0;
+        for (const pending of pendingObjects)
+            if (compareSemanticPoint(pending.point, point) < 0)
+                before++;
+        return point.usageIndex + before;
+    }
+    currentInteropProvider(snapshot) {
+        const provider = this.#jsInteropProvider;
+        if (provider === undefined || !isRecord(snapshot) || !isRecord(snapshot.ref))
+            return undefined;
+        return snapshot.ref.providerId === provider.id && snapshot.ref.generation === provider.generation ? provider : undefined;
+    }
+    isCurrentForeignSnapshot(snapshot, provider, allowUnknown) {
+        if (!isRecord(snapshot) || !isRecord(snapshot.ref))
+            return false;
+        if (snapshot.ref.providerId !== provider.id || snapshot.ref.generation !== provider.generation || typeof snapshot.ref.id !== 'string' || snapshot.ref.id.length === 0)
+            return false;
+        if (!Number.isSafeInteger(snapshot.ref.generation) || typeof snapshot.display !== 'string' || snapshot.display.length === 0)
+            return false;
+        const categories = allowUnknown
+            ? ['primitive', 'literal', 'object', 'function', 'constructor', 'promise', 'array', 'tuple', 'union', 'unknown']
+            : ['primitive', 'literal', 'object', 'function', 'constructor', 'promise', 'array', 'tuple', 'union'];
+        if (typeof snapshot.category !== 'string' || !categories.includes(snapshot.category))
+            return false;
+        const primitives = ['boolean', 'string', 'number', 'bigint', 'void', 'undefined', 'null'];
+        if (snapshot.primitive !== undefined && (typeof snapshot.primitive !== 'string' || !primitives.includes(snapshot.primitive)))
+            return false;
+        if (snapshot.category === 'primitive' && snapshot.primitive === undefined)
+            return false;
+        if (snapshot.primitive !== undefined && snapshot.category !== 'primitive' && snapshot.category !== 'literal')
+            return false;
+        if (snapshot.mustUse !== undefined && typeof snapshot.mustUse !== 'boolean')
+            return false;
+        if (snapshot.origin !== undefined) {
+            if (!isRecord(snapshot.origin) || typeof snapshot.origin.moduleSpecifier !== 'string' || snapshot.origin.moduleSpecifier.length === 0)
+                return false;
+            for (const field of ['packageName', 'packageVersion', 'declarationPath', 'exportName']) {
+                const value = snapshot.origin[field];
+                if (value !== undefined && typeof value !== 'string')
+                    return false;
+            }
+        }
+        if (snapshot.navigation !== undefined && (!isRecord(snapshot.navigation) || typeof snapshot.navigation.declarationPath !== 'string'))
+            return false;
+        try {
+            if (provider.display(snapshot.ref) !== snapshot.display)
+                return false;
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+    isValidForeignInvocationResolution(resolution, provider, target, construct, wholeUsage) {
+        if (!isRecord(resolution) || !this.isCurrentForeignSnapshot(resolution.result, provider, !construct))
+            return false;
+        if (!Number.isSafeInteger(resolution.parameterCount) || resolution.parameterCount < 0)
+            return false;
+        if (!Number.isSafeInteger(resolution.optionalParameterCount) || resolution.optionalParameterCount < 0 || resolution.optionalParameterCount > resolution.parameterCount)
+            return false;
+        const arityLowerBound = Math.max(0, resolution.parameterCount - resolution.optionalParameterCount);
+        if (resolution.minimumArgumentCount !== undefined && (!Number.isSafeInteger(resolution.minimumArgumentCount)
+            || resolution.minimumArgumentCount < arityLowerBound
+            || resolution.minimumArgumentCount > resolution.parameterCount))
+            return false;
+        if (wholeUsage && resolution.minimumArgumentCount === undefined)
+            return false;
+        if (typeof resolution.rest !== 'boolean' || typeof resolution.mayReject !== 'boolean')
+            return false;
+        if (resolution.receiverMode !== 'none' && resolution.receiverMode !== 'preserve-this')
+            return false;
+        if (wholeUsage) {
+            const expectedReceiverMode = construct || target.kind === 'value' ? 'none' : 'preserve-this';
+            if (resolution.receiverMode !== expectedReceiverMode)
+                return false;
+        }
+        return !construct || resolution.receiverMode === 'none';
+    }
+    nativeCallableBoundary(typeId, expression, allowInlineZeroArgument = false) {
+        const type = this.arena.get(typeId);
+        if (type.kind !== 'function' || type.typeParameters.length !== 0 || type.effects.some(effect => effect === '*' || !this.#effects.has(effect)))
+            return undefined;
+        if (expression.kind === 'LambdaExpression') {
+            if (!allowInlineZeroArgument || expression.async || expression.parameters.length !== 0 || type.parameters.length !== 0)
+                return undefined;
+        }
+        else {
+            if (expression.kind !== 'IdentifierExpression' || expression.symbolId === undefined)
+                return undefined;
+            const symbol = this.#symbols.get(expression.symbolId);
+            const declaration = symbol?.declaration;
+            if (symbol?.kind !== 'function' || declaration?.kind !== 'FunctionDeclaration')
+                return undefined;
+            const functionDeclaration = declaration;
+            if (functionDeclaration.typeParameters.length !== 0 || functionDeclaration.attributes.some(attribute => attribute.name === 'jsExport'))
+                return undefined;
+        }
+        const parameters = [];
+        for (const parameter of type.parameters) {
+            const primitive = this.nativeCallablePrimitive(parameter);
+            if (primitive === undefined)
+                return undefined;
+            parameters.push(primitive);
+        }
+        const result = this.nativeCallablePrimitive(type.result);
+        const effects = Object.freeze([...new Set(type.effects)].sort(compareText));
+        if (result !== undefined) {
+            return Object.freeze({
+                version: 'virune-callable-shim/v1',
+                parameters: Object.freeze(parameters),
+                result,
+                async: type.async,
+                effects,
+                contextMode: 'root-argument',
+            });
+        }
+        if (type.async)
+            return undefined;
+        const nested = this.arena.get(type.result);
+        if (nested.kind !== 'function' || nested.async || nested.typeParameters.length !== 0 || nested.effects.some(effect => effect === '*' || !this.#effects.has(effect)))
+            return undefined;
+        const nestedParameters = [];
+        for (const parameter of nested.parameters) {
+            const primitive = this.nativeCallablePrimitive(parameter);
+            if (primitive === undefined)
+                return undefined;
+            nestedParameters.push(primitive);
+        }
+        const nestedResult = this.nativeCallablePrimitive(nested.result);
+        if (nestedResult === undefined)
+            return undefined;
+        const nestedBoundary = Object.freeze({
+            version: 'virune-callable-shim/v1',
+            parameters: Object.freeze(nestedParameters),
+            result: nestedResult,
+            async: false,
+            effects: Object.freeze([...new Set(nested.effects)].sort(compareText)),
+            contextMode: 'root-argument',
+        });
+        return Object.freeze({
+            version: 'virune-callable-shim/v3',
+            parameters: Object.freeze(parameters),
+            result: nestedBoundary,
+            async: false,
+            effects,
+            contextMode: 'root-argument',
+        });
+    }
+    nativeCallablePrimitive(typeId) {
+        const type = this.arena.get(typeId);
+        if (type.kind !== 'primitive')
+            return undefined;
+        return ['Bool', 'Int', 'Float', 'BigInt', 'String', 'Unit'].includes(type.name) ? type.name : undefined;
+    }
+    externalInlineCallableProjection(typeId, expression) {
+        const type = this.arena.get(typeId);
+        if (type.kind !== 'function' || type.async !== expression.async || type.typeParameters.length !== 0 || type.parameters.length === 0 || type.effects.some(effect => effect === '*' || !this.#effects.has(effect)))
+            return undefined;
+        const parameters = [];
+        for (const parameter of type.parameters) {
+            const foreign = this.currentExternalObjectRef(parameter);
+            if (foreign === undefined)
+                return undefined;
+            parameters.push({ kind: 'foreign', type: foreign });
+        }
+        const resultType = this.arena.get(type.result);
+        const result = resultType.kind === 'primitive' && resultType.name === 'Never' ? 'Never' : this.currentExternalRef(type.result);
+        if (result === undefined)
+            return undefined;
+        return Object.freeze({
+            callable: Object.freeze({
+                parameters: Object.freeze(parameters),
+                result: result === 'Never' ? result : { kind: 'foreign', type: result },
+                async: type.async,
+            }),
+            boundary: Object.freeze({
+                version: 'virune-callable-shim/v2',
+                parameters: Object.freeze(parameters.map(() => 'External')),
+                result: result === 'Never' ? 'Never' : 'External',
+                async: type.async,
+                effects: Object.freeze([...new Set(type.effects)].sort(compareText)),
+                contextMode: 'root-argument',
+            }),
+        });
+    }
+    currentExternalRef(typeId) {
+        const type = this.arena.get(typeId);
+        if (type.kind !== 'foreign')
+            return undefined;
+        const provider = this.currentInteropProvider(type.snapshot);
+        return provider !== undefined && this.isCurrentForeignSnapshot(type.snapshot, provider, false) ? type.ref : undefined;
+    }
+    currentExternalObjectRef(typeId) {
+        const type = this.arena.get(typeId);
+        if (type.kind !== 'foreign' || type.snapshot.category !== 'object')
+            return undefined;
+        const provider = this.currentInteropProvider(type.snapshot);
+        return provider !== undefined && this.isCurrentForeignSnapshot(type.snapshot, provider, false) ? type.ref : undefined;
+    }
+    validateContextualCallableArgumentEvidence(raw, interopArguments, provider) {
+        const expectedIndexes = interopArguments.flatMap((argument, index) => argument.kind === 'contextual-callable' ? [index] : []);
+        if (expectedIndexes.length === 0)
+            return raw === undefined || Array.isArray(raw) && raw.length === 0 ? [] : undefined;
+        if (!Array.isArray(raw) || raw.length !== expectedIndexes.length)
+            return undefined;
+        const result = [];
+        for (let position = 0; position < raw.length; position++) {
+            const item = raw[position];
+            const expectedIndex = expectedIndexes[position];
+            if (!isRecord(item) || !hasExactEnumerableKeys(item, ['index', 'target']) || item.index !== expectedIndex || expectedIndex === undefined)
+                return undefined;
+            const target = item.target;
+            const expectedArgument = interopArguments[expectedIndex];
+            if (!isRecord(target) || !hasExactEnumerableKeys(target, ['parameters', 'result']) || !Array.isArray(target.parameters) || expectedArgument?.kind !== 'contextual-callable' || target.parameters.length !== expectedArgument.parameterCount)
+                return undefined;
+            const parameters = target.parameters.every(parameter => typeof parameter !== 'string' && parameter.category === 'object' && this.isCurrentForeignSnapshot(parameter, provider, false))
+                ? Object.freeze(target.parameters)
+                : undefined;
+            const contextualResult = canonicalContextualCallableResult(target.result);
+            if (parameters === undefined || contextualResult?.kind !== 'deferred')
+                return undefined;
+            result.push(Object.freeze({ index: expectedIndex, target: Object.freeze({ parameters, result: contextualResult }) }));
+        }
+        return Object.freeze(result);
+    }
+    validateCallableArgumentEvidence(raw, interopArguments, boundaries, provider) {
+        const expectedIndexes = interopArguments.flatMap((argument, index) => argument.kind === 'native-callable' ? [index] : []);
+        if (expectedIndexes.length === 0)
+            return raw === undefined || Array.isArray(raw) && raw.length === 0 ? [] : undefined;
+        if (!Array.isArray(raw) || raw.length !== expectedIndexes.length)
+            return undefined;
+        const result = [];
+        for (let position = 0; position < raw.length; position++) {
+            const item = raw[position];
+            if (!isRecord(item) || !hasExactEnumerableKeys(item, ['index', 'target']))
+                return undefined;
+            const index = item.index;
+            const expectedIndex = expectedIndexes.at(position);
+            if (typeof index !== 'number' || !Number.isSafeInteger(index) || index < 0 || expectedIndex === undefined || index !== expectedIndex)
+                return undefined;
+            const target = item.target;
+            const boundary = boundaries.at(index);
+            if (!isRecord(target) || !hasExactEnumerableKeys(target, ['parameters', 'result']) || !Array.isArray(target.parameters) || boundary === undefined)
+                return undefined;
+            const contextualResult = canonicalContextualCallableResult(target.result);
+            if (contextualResult === undefined)
+                return undefined;
+            let parameters;
+            if (boundary.version === 'virune-callable-shim/v1' || boundary.version === 'virune-callable-shim/v3') {
+                const primitives = [];
+                for (const parameter of target.parameters) {
+                    if (!isContextualCallablePrimitive(parameter))
+                        return undefined;
+                    primitives.push(parameter);
+                }
+                parameters = Object.freeze(primitives);
+            }
+            else {
+                if (!target.parameters.every(parameter => typeof parameter !== 'string' && parameter.category === 'object' && this.isCurrentForeignSnapshot(parameter, provider, false)))
+                    return undefined;
+                parameters = Object.freeze(target.parameters);
+            }
+            if (!this.callableBoundaryMatchesContext(boundary, parameters, contextualResult))
+                return undefined;
+            result.push(Object.freeze({ index, target: Object.freeze({ parameters, result: contextualResult }) }));
+        }
+        return Object.freeze(result);
+    }
+    contextualCallableTypeId(value, provider) {
+        return typeof value !== 'string' && value.category === 'object' && this.isCurrentForeignSnapshot(value, provider, false)
+            ? this.arena.foreign(value)
+            : undefined;
+    }
+    callableBoundaryMatchesContext(boundary, parameters, result) {
+        if (boundary.parameters.length !== parameters.length || result.kind === 'deferred')
+            return false;
+        if (boundary.version === 'virune-callable-shim/v3') {
+            if (boundary.async || result.kind !== 'callable' || parameters.some(parameter => typeof parameter !== 'string'))
+                return false;
+            if (boundary.parameters.some((parameter, index) => !callableParameterMatchesContext(parameter, parameters[index])))
+                return false;
+            return this.callableBoundaryMatchesContext(boundary.result, result.callable.parameters, result.callable.result);
+        }
+        if (boundary.version === 'virune-callable-shim/v2') {
+            return boundary.parameters.every(parameter => parameter === 'External')
+                && parameters.every(parameter => typeof parameter !== 'string')
+                && result.kind === 'external';
+        }
+        if (parameters.some(parameter => typeof parameter !== 'string'))
+            return false;
+        if (boundary.parameters.some((parameter, index) => !callableParameterMatchesContext(parameter, parameters[index])))
+            return false;
+        if (result.kind === 'external' || result.kind === 'callable')
+            return false;
+        if (result.kind === 'void')
+            return !boundary.async && boundary.result === 'Unit';
+        if (boundary.async !== (result.kind === 'promise'))
+            return false;
+        if (boundary.result === 'Unit')
+            return result.value === 'undefined' || result.kind === 'promise' && result.value === 'void';
+        return callablePrimitiveExternalName(boundary.result) === result.value;
+    }
+    interopArgumentType(typeId, expression, span) {
+        const type = this.arena.get(typeId);
+        if (type.kind === 'foreign')
+            return { kind: 'foreign', type: type.ref };
+        if (type.kind === 'primitive') {
+            if (type.name === 'Unknown' || type.name === 'Never' || type.name === 'InvalidType')
+                return { kind: 'unknown' };
+            const literal = this.interopLiteralValue(expression);
+            return literal === undefined ? { kind: 'native-primitive', primitive: type.name } : { kind: 'native-primitive', primitive: type.name, literal };
+        }
+        this.diagnostics.error('L4206', `Native value of type ${this.arena.display(typeId)} must be explicitly encoded before passing it to JavaScript`, span);
+        return { kind: 'unknown' };
+    }
+    interopLiteralValue(expression) {
+        let literal;
+        let negative = false;
+        if (expression.kind === 'LiteralExpression')
+            literal = expression;
+        else if (expression.kind === 'UnaryExpression' && expression.operator === '-' && expression.operand.kind === 'LiteralExpression' && ['Int', 'Float', 'BigInt'].includes(expression.operand.literalKind)) {
+            literal = expression.operand;
+            negative = true;
+        }
+        if (literal === undefined)
+            return undefined;
+        if (literal.literalKind === 'String' && typeof literal.value === 'string')
+            return { kind: 'String', value: literal.value };
+        if (literal.literalKind === 'Bool' && typeof literal.value === 'boolean')
+            return { kind: 'Bool', value: literal.value };
+        if ((literal.literalKind === 'Int' || literal.literalKind === 'Float') && typeof literal.value === 'number') {
+            const value = negative ? -literal.value : literal.value;
+            return Number.isFinite(value) ? { kind: literal.literalKind, value } : undefined;
+        }
+        if (literal.literalKind === 'BigInt' && typeof literal.value === 'bigint') {
+            const value = negative ? -literal.value : literal.value;
+            return { kind: 'BigInt', value: value.toString(10) };
+        }
+        return undefined;
+    }
+    applyExpectedForeignBridge(expression, actual, expected) {
+        if (expected === undefined)
+            return actual;
+        const source = this.arena.get(actual);
+        if (source.kind !== 'foreign')
+            return actual;
+        const provider = this.currentInteropProvider(source.snapshot);
+        if (provider === undefined || !this.isCurrentForeignSnapshot(source.snapshot, provider, true))
+            return actual;
+        const bridge = this.primitiveBridge(source.snapshot, expected);
+        if (bridge === undefined)
+            return actual;
+        expression.foreignBridge = bridge;
+        this.#interopUsages.push({ kind: 'bridge', nodeId: expression.id, span: expression.span, foreignType: source.snapshot, bridge: { kind: 'primitive', bridge, targetType: expected } });
+        return expected;
+    }
+    primitiveBridge(source, target) {
+        if (source.primitive === 'string' && this.arena.equals(target, this.arena.string))
+            return 'string';
+        if (source.primitive === 'boolean' && this.arena.equals(target, this.arena.bool))
+            return 'bool';
+        if (source.primitive === 'number' && this.arena.equals(target, this.arena.float))
+            return 'float';
+        if (source.primitive === 'bigint' && this.arena.equals(target, this.arena.bigint))
+            return 'bigint';
+        if (source.primitive === 'void' && this.arena.equals(target, this.arena.unit))
+            return 'unit';
+        if (source.category === 'unknown' && this.arena.equals(target, this.arena.unknown))
+            return 'unknown';
+        return undefined;
+    }
+    literalType(expression) {
+        switch (expression.literalKind) {
+            case 'String': return this.arena.string;
+            case 'Int':
+                if (!Number.isSafeInteger(expression.value))
+                    this.diagnostics.error('L2065', 'Int literal is outside the JavaScript safe integer range; use BigInt', expression.span);
+                return this.arena.int;
+            case 'Float': return this.arena.float;
+            case 'BigInt': return this.arena.bigint;
+            case 'Bool': return this.arena.bool;
+        }
+    }
+    checkCall(expression, scope, expected) {
+        if (expression.callee.kind === 'IdentifierExpression') {
+            const component = scope.lookup(expression.callee.name);
+            if (component?.kind === 'component') {
+                expression.callee.symbolId = component.id;
+                this.diagnostics.error('L4305', `Component ${expression.callee.name} cannot be called as an ordinary Virune function; use it as a View tag`, expression.callee.span);
+                for (const argument of expression.arguments)
+                    this.checkExpression(argument, scope);
+                return this.arena.error;
+            }
+        }
+        const calleeTypeId = this.checkExpression(expression.callee, scope);
+        const calleeType = this.arena.get(calleeTypeId);
+        if (calleeType.kind === 'foreign')
+            return this.checkForeignCall(expression, scope, calleeType.snapshot);
+        if (calleeType.kind !== 'function') {
+            this.diagnostics.error('L2012', `Value of type ${this.arena.display(calleeTypeId)} is not callable`, expression.callee.span);
+            expression.arguments.forEach(arg => this.checkExpression(arg, scope));
+            return this.arena.error;
+        }
+        this.requireEffects(calleeType.effects.filter(effect => effect !== '*'), expression.span);
+        if (expression.arguments.length !== calleeType.parameters.length)
+            this.diagnostics.error('L2013', `Expected ${calleeType.parameters.length} arguments, received ${expression.arguments.length}`, expression.span);
+        const substitutions = new Map();
+        const argumentTypes = [];
+        if (expression.typeArguments.length > 0) {
+            if (expression.typeArguments.length !== calleeType.typeParameters.length)
+                this.diagnostics.error('L2046', `Expected ${calleeType.typeParameters.length} type arguments, received ${expression.typeArguments.length}`, expression.span);
+            expression.typeArguments.forEach((argument, index) => {
+                const name = calleeType.typeParameters[index];
+                if (name !== undefined)
+                    substitutions.set(name, this.resolveTypeReference(argument, this.#currentFunction?.typeParameters ?? new Map()));
+            });
+        }
+        expression.arguments.forEach((argument, index) => {
+            const parameter = calleeType.parameters[index] ?? this.arena.error;
+            const argumentType = this.checkExpression(argument, scope, parameter);
+            argumentTypes.push(argumentType);
+            this.unify(parameter, argumentType, substitutions);
+            const substituted = this.substitute(parameter, substitutions);
+            if (!this.isAssignable(argumentType, substituted))
+                this.typeMismatch(argumentType, substituted, argument.span);
+            const argumentFunction = this.arena.get(argumentType);
+            if (argumentFunction.kind === 'function')
+                this.requireEffects(argumentFunction.effects.filter(effect => effect !== '*'), argument.span);
+        });
+        if (expected !== undefined)
+            this.unify(calleeType.result, expected, substitutions);
+        const result = this.substitute(calleeType.result, substitutions);
+        if (expression.callee.kind === 'FieldExpression' && expression.callee.target.kind === 'IdentifierExpression' && expression.callee.target.name === 'Json') {
+            const resultType = this.arena.get(result);
+            const jsonTarget = expression.callee.field === 'decode' && resultType.kind === 'result' ? resultType.value : expression.callee.field === 'encode' ? argumentTypes[0] : undefined;
+            if (jsonTarget !== undefined) {
+                if (this.containsTypeVariable(jsonTarget))
+                    this.diagnostics.error('L2047', `Cannot infer JSON target type for Json.${expression.callee.field}`, expression.span);
+                else if (!this.supportsJson(jsonTarget))
+                    this.diagnostics.error('L2048', `Type ${this.arena.display(jsonTarget)} does not support Json`, expression.span);
+            }
+        }
+        if (expression.callee.kind === 'FieldExpression' && expression.callee.target.kind === 'IdentifierExpression') {
+            const namespace = expression.callee.target.name;
+            const target = argumentTypes[0];
+            if (namespace === 'Debug' && target !== undefined && !this.supportsDerive(target, 'Debug'))
+                this.diagnostics.error('L2063', `Type ${this.arena.display(target)} does not support Debug`, expression.span);
+            if (namespace === 'Map') {
+                const key = substitutions.get('T') ?? (expression.callee.field === 'empty' ? undefined : expression.callee.field === 'size' || expression.callee.field === 'keys' || expression.callee.field === 'values' || expression.callee.field === 'entries' || expression.callee.field === 'mapValues' ? this.mapKeyOf(argumentTypes[0]) : argumentTypes[1]);
+                if (key !== undefined && (!this.supportsEq(key) || !this.supportsHash(key)))
+                    this.diagnostics.error('L2109', `Map key type ${this.arena.display(key)} must support structural Eq and Hash`, expression.span);
+            }
+            if (namespace === 'Set') {
+                const element = substitutions.get('T') ?? (expression.callee.field === 'from' ? this.listElementOf(argumentTypes[0]) : expression.callee.field === 'empty' ? undefined : this.setElementOf(argumentTypes[0]) ?? argumentTypes[1]);
+                if (element !== undefined && (!this.supportsEq(element) || !this.supportsHash(element)))
+                    this.diagnostics.error('L2110', `Set element type ${this.arena.display(element)} must support structural Eq and Hash`, expression.span);
+            }
+            if (namespace === 'List' && expression.callee.field === 'unique') {
+                const element = this.listElementOf(argumentTypes[0]);
+                if (element !== undefined && (!this.supportsEq(element) || !this.supportsHash(element)))
+                    this.diagnostics.error('L2111', `List.unique element type ${this.arena.display(element)} must support structural Eq and Hash`, expression.span);
+            }
+            if (namespace === 'List' && expression.callee.field === 'uniqueBy') {
+                const key = substitutions.get('U');
+                if (key !== undefined && (!this.supportsEq(key) || !this.supportsHash(key)))
+                    this.diagnostics.error('L2111', `List.uniqueBy key type ${this.arena.display(key)} must support structural Eq and Hash`, expression.span);
+            }
+        }
+        return calleeType.async ? this.arena.future(result) : result;
+    }
+    checkField(expression, scope) {
+        if (expression.target.kind === 'IdentifierExpression') {
+            const namespace = expression.target.name;
+            this.checkBuiltinPlatform(namespace, expression.span);
+            const builtin = this.builtinMember(namespace, expression.field);
+            if (builtin !== undefined) {
+                this.checkExpression(expression.target, scope);
+                return builtin;
+            }
+            const symbol = scope.lookup(namespace);
+            if (symbol?.kind === 'type') {
+                const named = this.arena.get(symbol.typeId);
+                if (named.kind === 'named' && named.declarationKind === 'newtype' && named.underlying !== undefined && expression.field === 'create') {
+                    expression.target.symbolId = symbol.id;
+                    if (symbol.typeOnly)
+                        this.diagnostics.error('L1012', `Type-only import ${namespace} cannot be used as a value`, expression.span);
+                    if (symbol.declaration !== undefined && this.#signatureOnlyNodeIds.has(symbol.declaration.id))
+                        this.diagnostics.error('L2117', `newtype constructor ${namespace}.create is private to its declaring module`, expression.span);
+                    return this.arena.function([named.underlying], symbol.typeId);
+                }
+                if (named.kind === 'named' && named.declarationKind === 'enum' && named.variants?.has(expression.field)) {
+                    expression.target.symbolId = symbol.id;
+                    if (symbol.typeOnly)
+                        this.diagnostics.error('L1012', `Type-only import ${namespace} cannot be used as a value`, expression.span);
+                    const values = named.variants.get(expression.field) ?? [];
+                    return values.length === 0 ? symbol.typeId : this.arena.function(values, symbol.typeId);
+                }
+            }
+        }
+        const targetTypeId = this.checkExpression(expression.target, scope);
+        const targetType = this.arena.get(targetTypeId);
+        if (targetType.kind === 'foreign') {
+            this.requireEffects(['JavaScript'], expression.span);
+            const property = this.#jsInteropProvider?.getProperty(targetType.ref, expression.field);
+            if (property === undefined) {
+                this.diagnostics.error('L4202', `Foreign type ${targetType.snapshot.display} has no accessible property ${expression.field}`, expression.span);
+                return this.arena.error;
+            }
+            this.#interopUsages.push({ kind: 'property', nodeId: expression.id, span: expression.span, foreignType: property });
+            return this.arena.foreign(property);
+        }
+        if (targetType.kind === 'named' && targetType.fields?.has(expression.field))
+            return targetType.fields.get(expression.field);
+        if (targetType.kind === 'list' && expression.field === 'length')
+            return this.arena.int;
+        this.diagnostics.error('L2014', `Type ${this.arena.display(targetTypeId)} has no field ${expression.field}`, expression.span);
+        return this.arena.error;
+    }
+    builtinMember(namespace, member) {
+        return builtinMember(this.arena, this.#namedTypes, namespace, member);
+    }
+    checkBuiltinPlatform(namespace, span) {
+        const nodeOnly = new Set(['File', 'Path', 'Process', 'Http', 'Crypto']);
+        const browserOnly = new Set(['Fetch', 'Storage', 'Dom']);
+        if (nodeOnly.has(namespace) && this.#platform !== 'node')
+            this.diagnostics.error('L4010', `${namespace} is only available on the node platform`, span);
+        if (browserOnly.has(namespace) && this.#platform !== 'browser')
+            this.diagnostics.error('L4011', `${namespace} is only available on the browser platform`, span);
+    }
+    requireEffects(required, span) {
+        if (required.length === 0)
+            return;
+        const allowed = this.#currentFunction?.effects;
+        for (const effect of required) {
+            if (allowed?.has('*') === true || allowed?.has(effect) === true)
+                continue;
+            this.diagnostics.error('L2076', `Effect ${effect} is not declared by the enclosing function; add uses ${effect}`, span);
+        }
+    }
+    validateEffects(effects, span) {
+        for (const effect of effects)
+            if (effect !== '*' && !this.#effects.has(effect))
+                this.diagnostics.error('L2085', `Unknown effect ${effect}; Virune supports only built-in effects`, span);
+    }
+    checkBinary(expression, scope) {
+        const booleanOperands = expression.operator === '&&' || expression.operator === '||';
+        const left = this.checkExpression(expression.left, scope, booleanOperands ? this.arena.bool : undefined);
+        const right = this.checkExpression(expression.right, scope, booleanOperands ? this.arena.bool : undefined);
+        if (['&&', '||'].includes(expression.operator)) {
+            this.requireBool(left, expression.left.span);
+            this.requireBool(right, expression.right.span);
+            return this.arena.bool;
+        }
+        if (['==', '!='].includes(expression.operator)) {
+            if (!this.arena.equals(left, right))
+                this.typeMismatch(right, left, expression.right.span);
+            else if (!this.supportsEq(left))
+                this.diagnostics.error('L2049', `Type ${this.arena.display(left)} does not support equality`, expression.span);
+            return this.arena.bool;
+        }
+        if (['<', '<=', '>', '>='].includes(expression.operator)) {
+            if (!this.arena.equals(left, right) || ![this.arena.int, this.arena.float, this.arena.bigint, this.arena.string].includes(left))
+                this.diagnostics.error('L2015', 'Comparison requires operands of the same ordered type', expression.span);
+            return this.arena.bool;
+        }
+        if (!this.arena.equals(left, right)) {
+            this.typeMismatch(right, left, expression.right.span);
+            return this.arena.error;
+        }
+        if (expression.operator === '+' && left === this.arena.string)
+            return this.arena.string;
+        if (![this.arena.int, this.arena.float, this.arena.bigint].includes(left)) {
+            this.diagnostics.error('L2016', `Operator ${expression.operator} cannot be applied to ${this.arena.display(left)}`, expression.span);
+            return this.arena.error;
+        }
+        return left;
+    }
+    checkUnary(expression, scope) {
+        const operand = this.checkExpression(expression.operand, scope, expression.operator === '!' ? this.arena.bool : undefined);
+        if (expression.operator === '!') {
+            this.requireBool(operand, expression.operand.span);
+            return this.arena.bool;
+        }
+        if (![this.arena.int, this.arena.float, this.arena.bigint].includes(operand))
+            this.diagnostics.error('L2017', 'Unary minus requires a numeric value', expression.span);
+        return operand;
+    }
+    checkPipeline(expression, scope) {
+        const leftType = this.checkExpression(expression.left, scope);
+        if (expression.right.kind === 'CallExpression') {
+            const calleeTypeId = this.checkExpression(expression.right.callee, scope);
+            const callee = this.arena.get(calleeTypeId);
+            if (callee.kind !== 'function')
+                return this.arena.error;
+            this.requireEffects(callee.effects.filter(effect => effect !== '*'), expression.right.span);
+            const args = [expression.left, ...expression.right.arguments];
+            if (callee.parameters.length !== args.length)
+                this.diagnostics.error('L2018', `Pipeline target expects ${callee.parameters.length} arguments`, expression.right.span);
+            const substitutions = new Map();
+            if (expression.right.typeArguments.length > 0) {
+                if (expression.right.typeArguments.length !== callee.typeParameters.length)
+                    this.diagnostics.error('L2046', `Expected ${callee.typeParameters.length} type arguments, received ${expression.right.typeArguments.length}`, expression.right.span);
+                expression.right.typeArguments.forEach((argument, index) => { const name = callee.typeParameters[index]; if (name !== undefined)
+                    substitutions.set(name, this.resolveTypeReference(argument, this.#currentFunction?.typeParameters ?? new Map())); });
+            }
+            for (let index = 0; index < args.length; index++) {
+                const argument = args[index];
+                const parameter = callee.parameters[index] ?? this.arena.error;
+                const actual = index === 0 ? leftType : this.checkExpression(argument, scope, this.substitute(parameter, substitutions));
+                this.unify(parameter, actual, substitutions);
+                const expectedParameter = this.substitute(parameter, substitutions);
+                if (!this.isAssignable(actual, expectedParameter))
+                    this.typeMismatch(actual, expectedParameter, argument.span);
+                const callback = this.arena.get(actual);
+                if (callback.kind === 'function')
+                    this.requireEffects(callback.effects.filter(effect => effect !== '*'), argument.span);
+            }
+            const result = this.substitute(callee.result, substitutions);
+            return callee.async ? this.arena.future(result) : result;
+        }
+        const calleeTypeId = this.checkExpression(expression.right, scope);
+        const callee = this.arena.get(calleeTypeId);
+        if (callee.kind !== 'function' || callee.parameters.length !== 1) {
+            this.diagnostics.error('L2019', 'Pipeline target must be a function accepting the piped value', expression.right.span);
+            return this.arena.error;
+        }
+        this.requireEffects(callee.effects.filter(effect => effect !== '*'), expression.right.span);
+        if (!this.isAssignable(leftType, callee.parameters[0]))
+            this.typeMismatch(leftType, callee.parameters[0], expression.left.span);
+        return callee.async ? this.arena.future(callee.result) : callee.result;
+    }
+    checkTry(expression, scope) {
+        const operandId = this.checkExpression(expression.operand, scope);
+        const operand = this.arena.get(operandId);
+        const returnId = this.#currentFunction?.returnType;
+        if (returnId === undefined) {
+            this.diagnostics.error('L2020', '? requires an enclosing function with a known return type', expression.span);
+            return this.arena.error;
+        }
+        const returnType = this.arena.get(returnId);
+        if (operand.kind === 'result' && returnType.kind === 'result') {
+            if (!this.arena.equals(operand.error, returnType.error))
+                this.typeMismatch(operand.error, returnType.error, expression.span);
+            return operand.value;
+        }
+        if (operand.kind === 'option' && returnType.kind === 'option')
+            return operand.value;
+        this.diagnostics.error('L2021', `Cannot propagate ${this.arena.display(operandId)} from function returning ${this.arena.display(returnId)}`, expression.span);
+        return this.arena.error;
+    }
+    checkAwait(expression, scope) {
+        if (!this.#currentFunction?.async)
+            this.diagnostics.error('L2022', 'await can only be used in an async function or test', expression.span);
+        const operandId = this.checkExpression(expression.operand, scope);
+        const operand = this.arena.get(operandId);
+        if (operand.kind === 'foreign') {
+            this.requireEffects(['JavaScript'], expression.span);
+            const awaited = this.#jsInteropProvider?.getAwaitedType(operand.ref);
+            if (awaited === undefined) {
+                this.diagnostics.error('L2023', `await requires Future or JavaScript PromiseLike, received ${this.arena.display(operandId)}`, expression.span);
+                return this.arena.error;
+            }
+            this.#interopUsages.push({ kind: 'await', nodeId: expression.id, span: expression.span, foreignType: awaited, mayReject: true });
+            return this.arena.foreign(awaited);
+        }
+        if (operand.kind !== 'future') {
+            this.diagnostics.error('L2023', `await requires Future, received ${this.arena.display(operandId)}`, expression.span);
+            return this.arena.error;
+        }
+        return operand.value;
+    }
+    checkRecord(expression, scope, expected) {
+        const typeId = this.#namedTypes.get(expression.name);
+        const type = typeId === undefined ? undefined : this.arena.get(typeId);
+        if (typeId === undefined || type?.kind !== 'named' || type.declarationKind !== 'record' || type.fields === undefined) {
+            this.diagnostics.error('L2024', `Unknown record type ${expression.name}`, expression.span);
+            expression.entries.forEach(entry => this.checkExpression(entry.value, scope));
+            return this.arena.error;
+        }
+        const declaration = this.#recordDeclarations.get(expression.name);
+        const substitutions = new Map();
+        if (declaration !== undefined && expression.typeArguments.length > 0) {
+            if (expression.typeArguments.length !== declaration.typeParameters.length)
+                this.diagnostics.error('L2046', `Expected ${declaration.typeParameters.length} type arguments, received ${expression.typeArguments.length}`, expression.span);
+            expression.typeArguments.forEach((argument, index) => {
+                const parameter = declaration.typeParameters[index];
+                if (parameter !== undefined)
+                    substitutions.set(parameter.name, this.resolveTypeReference(argument, this.#currentFunction?.typeParameters ?? new Map()));
+            });
+        }
+        if (expected !== undefined) {
+            const expectedType = this.arena.get(expected);
+            if (expectedType.kind === 'named' && expectedType.name === expression.name && declaration !== undefined) {
+                declaration.typeParameters.forEach((parameter, index) => {
+                    const expectedArgument = expectedType.arguments[index] ?? this.arena.error;
+                    const explicitArgument = substitutions.get(parameter.name);
+                    if (explicitArgument === undefined)
+                        substitutions.set(parameter.name, expectedArgument);
+                });
+            }
+        }
+        const supplied = new Set();
+        for (const entry of expression.entries) {
+            if (supplied.has(entry.name))
+                this.diagnostics.error('L2025', `Duplicate record field ${entry.name}`, entry.span);
+            supplied.add(entry.name);
+            const rawExpected = type.fields.get(entry.name);
+            const preliminaryExpected = rawExpected === undefined ? undefined : this.substitute(rawExpected, substitutions);
+            const actual = this.checkExpression(entry.value, scope, preliminaryExpected);
+            if (rawExpected === undefined)
+                this.diagnostics.error('L2026', `Record ${expression.name} has no field ${entry.name}`, entry.span);
+            else {
+                this.unify(rawExpected, actual, substitutions);
+                const fieldExpected = this.substitute(rawExpected, substitutions);
+                if (!this.isAssignable(actual, fieldExpected))
+                    this.typeMismatch(actual, fieldExpected, entry.value.span);
+            }
+        }
+        for (const field of type.fields.keys())
+            if (!supplied.has(field))
+                this.diagnostics.error('L2027', `Missing record field ${field}`, expression.span);
+        if (declaration === undefined || declaration.typeParameters.length === 0)
+            return typeId;
+        const argumentsList = declaration.typeParameters.map(parameter => substitutions.get(parameter.name) ?? this.arena.error);
+        declaration.typeParameters.forEach((parameter, index) => { if (argumentsList[index] === this.arena.error)
+            this.diagnostics.error('L2045', `Cannot infer type argument ${parameter.name} for ${expression.name}`, expression.span); });
+        return this.arena.namedInstance(type, argumentsList, { fields: new Map([...type.fields].map(([name, field]) => [name, this.substitute(field, substitutions)])) });
+    }
+    checkRecordUpdate(expression, scope) {
+        const base = this.checkExpression(expression.base, scope);
+        const type = this.arena.get(base);
+        if (type.kind !== 'named' || type.declarationKind !== 'record' || type.fields === undefined) {
+            this.diagnostics.error('L2028', 'Record update requires a record value', expression.base.span);
+            return this.arena.error;
+        }
+        for (const entry of expression.entries) {
+            const expected = type.fields.get(entry.name);
+            const actual = this.checkExpression(entry.value, scope, expected);
+            if (expected === undefined)
+                this.diagnostics.error('L2029', `Record has no field ${entry.name}`, entry.span);
+            else if (!this.isAssignable(actual, expected))
+                this.typeMismatch(actual, expected, entry.value.span);
+        }
+        return base;
+    }
+    checkList(expression, scope, expected) {
+        if (expression.items.length === 0) {
+            const expectedType = expected === undefined ? undefined : this.arena.get(expected);
+            if (expected !== undefined && expectedType?.kind === 'list')
+                return expected;
+            this.diagnostics.error('L2030', 'Empty List requires an explicit type annotation', expression.span);
+            return this.arena.list(this.arena.error);
+        }
+        const itemTypes = expression.items.map(item => this.checkExpression(item, scope));
+        const element = this.commonType(itemTypes, expression.span);
+        return this.arena.list(element);
+    }
+    checkMatch(expression, scope, expected) {
+        const target = this.checkExpression(expression.target, scope);
+        const resultTypes = [];
+        const covered = new Set();
+        const seenPatterns = new Set();
+        let wildcard = false;
+        for (const arm of expression.arms) {
+            const child = new Scope(scope);
+            const key = this.checkPattern(arm.pattern, target, child);
+            if (arm.guard === undefined && key === '*')
+                wildcard = true;
+            else if (arm.guard === undefined && key !== undefined) {
+                if (seenPatterns.has(key))
+                    this.diagnostics.error('L3002', `Unreachable duplicate pattern ${key}`, arm.pattern.span);
+                seenPatterns.add(key);
+                covered.add(key.includes('(') ? key.slice(0, key.indexOf('(')) : key);
+            }
+            if (arm.guard !== undefined)
+                this.requireBool(this.checkExpression(arm.guard, child, this.arena.bool), arm.guard.span);
+            resultTypes.push(this.checkExpression(arm.expression, child, expected));
+        }
+        const targetType = this.arena.get(target);
+        if (!wildcard) {
+            if (target === this.arena.bool && (!covered.has('true') || !covered.has('false')))
+                this.diagnostics.error('L3003', 'Bool match must cover true and false', expression.span);
+            if (targetType.kind === 'named' && targetType.declarationKind === 'enum' && targetType.variants !== undefined)
+                for (const name of targetType.variants.keys())
+                    if (!covered.has(name))
+                        this.diagnostics.error('L3004', `Non-exhaustive match: missing ${name}`, expression.span);
+            if (targetType.kind === 'option')
+                for (const name of ['Some', 'None'])
+                    if (!covered.has(name))
+                        this.diagnostics.error('L3004', `Non-exhaustive match: missing ${name}`, expression.span);
+            if (targetType.kind === 'result')
+                for (const name of ['Ok', 'Err'])
+                    if (!covered.has(name))
+                        this.diagnostics.error('L3004', `Non-exhaustive match: missing ${name}`, expression.span);
+            if ([this.arena.int, this.arena.string].includes(target))
+                this.diagnostics.error('L3005', 'Int and String matches require a wildcard arm', expression.span);
+        }
+        return this.commonType(resultTypes, expression.span);
+    }
+    checkPattern(pattern, target, scope) {
+        switch (pattern.kind) {
+            case 'WildcardPattern': return '*';
+            case 'BindingPattern': {
+                const symbol = this.#factory.create(pattern.name, 'variable', target, pattern.span, { declaration: pattern });
+                if (!scope.define(symbol))
+                    this.diagnostics.error('L1011', `Pattern name ${pattern.name} shadows an existing name`, pattern.span);
+                else {
+                    pattern.symbolId = symbol.id;
+                    this.#symbols.set(symbol.id, symbol);
+                }
+                return '*';
+            }
+            case 'LiteralPattern': {
+                const literalType = pattern.literalKind === 'Bool' ? this.arena.bool : pattern.literalKind === 'Int' ? this.arena.int : this.arena.string;
+                if (!this.arena.equals(literalType, target))
+                    this.typeMismatch(literalType, target, pattern.span);
+                return String(pattern.value);
+            }
+            case 'VariantPattern': {
+                let values;
+                let enumType;
+                if (pattern.name === 'Some') {
+                    const t = this.arena.get(target);
+                    if (t.kind === 'option') {
+                        values = [t.value];
+                        enumType = target;
+                    }
+                }
+                else if (pattern.name === 'None') {
+                    const t = this.arena.get(target);
+                    if (t.kind === 'option') {
+                        values = [];
+                        enumType = target;
+                    }
+                }
+                else if (pattern.name === 'Ok') {
+                    const t = this.arena.get(target);
+                    if (t.kind === 'result') {
+                        values = [t.value];
+                        enumType = target;
+                    }
+                }
+                else if (pattern.name === 'Err') {
+                    const t = this.arena.get(target);
+                    if (t.kind === 'result') {
+                        values = [t.error];
+                        enumType = target;
+                    }
+                }
+                else {
+                    const variant = this.#variants.get(pattern.name);
+                    if (variant !== undefined) {
+                        const substitutions = new Map();
+                        this.unify(variant.enumType, target, substitutions);
+                        values = variant.valueTypes.map(value => this.substitute(value, substitutions));
+                        enumType = this.substitute(variant.enumType, substitutions);
+                        pattern.symbolId = variant.symbol.id;
+                    }
+                }
+                if (values === undefined || enumType === undefined || !this.arena.equals(enumType, target)) {
+                    this.diagnostics.error('L2031', `Variant ${pattern.name} does not belong to ${this.arena.display(target)}`, pattern.span);
+                    return pattern.name;
+                }
+                if (values.length !== pattern.values.length)
+                    this.diagnostics.error('L2032', `Variant ${pattern.name} expects ${values.length} patterns`, pattern.span);
+                const childKeys = pattern.values.map((item, index) => this.checkPattern(item, values[index] ?? this.arena.error, scope) ?? '?');
+                return `${pattern.name}(${childKeys.join(',')})`;
+            }
+            case 'RecordPattern': {
+                const typeId = this.#namedTypes.get(pattern.name);
+                const type = typeId === undefined ? undefined : this.arena.get(typeId);
+                if (typeId === undefined || !this.arena.equals(typeId, target) || type?.kind !== 'named' || type.fields === undefined)
+                    this.diagnostics.error('L2033', `Record pattern ${pattern.name} does not match ${this.arena.display(target)}`, pattern.span);
+                else
+                    for (const field of pattern.fields) {
+                        const fieldType = type.fields.get(field.name);
+                        if (fieldType === undefined)
+                            this.diagnostics.error('L2034', `Unknown field ${field.name}`, field.span);
+                        else
+                            this.checkPattern(field.pattern, fieldType, scope);
+                    }
+                return '*';
+            }
+            case 'RangePattern': {
+                if (!this.arena.equals(target, this.arena.int))
+                    this.typeMismatch(this.arena.int, target, pattern.span);
+                if (pattern.start > pattern.end)
+                    this.diagnostics.error('L2073', 'Range pattern start must not exceed its end', pattern.span);
+                return `${pattern.start}..=${pattern.end}`;
+            }
+            case 'ListPattern': {
+                const targetType = this.arena.get(target);
+                if (targetType.kind !== 'list') {
+                    this.diagnostics.error('L2074', `List pattern does not match ${this.arena.display(target)}`, pattern.span);
+                    return '*';
+                }
+                for (const item of pattern.items)
+                    this.checkPattern(item, targetType.element, scope);
+                if (pattern.rest?.kind === 'BindingPattern') {
+                    const symbol = this.#factory.create(pattern.rest.name, 'variable', target, pattern.rest.span, { declaration: pattern.rest });
+                    if (!scope.define(symbol))
+                        this.diagnostics.error('L1011', `Pattern name ${pattern.rest.name} shadows an existing name`, pattern.rest.span);
+                    else {
+                        pattern.rest.symbolId = symbol.id;
+                        this.#symbols.set(symbol.id, symbol);
+                    }
+                }
+                return '*';
+            }
+            case 'TuplePattern': {
+                const targetType = this.arena.get(target);
+                if (targetType.kind !== 'tuple') {
+                    this.diagnostics.error('L2111', `Tuple pattern does not match ${this.arena.display(target)}`, pattern.span);
+                    return '*';
+                }
+                if (targetType.items.length !== pattern.items.length)
+                    this.diagnostics.error('L2112', `Tuple pattern expects ${targetType.items.length} items, received ${pattern.items.length}`, pattern.span);
+                pattern.items.forEach((item, index) => this.checkPattern(item, targetType.items[index] ?? this.arena.error, scope));
+                return '*';
+            }
+            case 'OrPattern': {
+                if (pattern.alternatives.some(item => this.patternHasBinding(item)))
+                    this.diagnostics.error('L2075', 'OR patterns cannot bind names in Virune 1.0', pattern.span);
+                return pattern.alternatives.map(item => this.checkPattern(item, target, new Scope(scope)) ?? '?').join('|');
+            }
+        }
+    }
+    patternHasBinding(pattern) {
+        switch (pattern.kind) {
+            case 'BindingPattern': return true;
+            case 'VariantPattern': return pattern.values.some(item => this.patternHasBinding(item));
+            case 'RecordPattern': return pattern.fields.some(field => this.patternHasBinding(field.pattern));
+            case 'ListPattern': return pattern.items.some(item => this.patternHasBinding(item)) || pattern.rest?.kind === 'BindingPattern';
+            case 'TuplePattern': return pattern.items.some(item => this.patternHasBinding(item));
+            case 'OrPattern': return pattern.alternatives.some(item => this.patternHasBinding(item));
+            default: return false;
+        }
+    }
+    checkLambda(expression, scope, expected, contextualParameters) {
+        const expectedType = expected === undefined ? undefined : this.arena.get(expected);
+        const child = new Scope(scope);
+        const parameters = [];
+        expression.parameters.forEach((parameter, index) => {
+            const contextual = contextualParameters?.[index];
+            const typeId = parameter.annotation === undefined ? contextual ?? (expectedType?.kind === 'function' ? expectedType.parameters[index] ?? this.arena.error : this.arena.error) : this.resolveTypeReference(parameter.annotation, new Map());
+            if (typeId === this.arena.error)
+                this.diagnostics.error('L2035', `Cannot infer type of lambda parameter ${parameter.name}`, parameter.span);
+            const symbol = this.#factory.create(parameter.name, 'parameter', typeId, parameter.span, { declaration: expression });
+            if (!child.define(symbol))
+                this.diagnostics.error('L1012', `Lambda parameter ${parameter.name} shadows an existing name`, parameter.span);
+            else {
+                parameter.symbolId = symbol.id;
+                this.#symbols.set(symbol.id, symbol);
+            }
+            parameters.push(typeId);
+        });
+        if (expectedType?.kind === 'function' && expression.async !== expectedType.async)
+            this.diagnostics.error('L2083', `Lambda async mode does not match expected ${expectedType.async ? 'async ' : ''}function`, expression.span);
+        const expectedResult = expression.returnType === undefined ? expectedType?.kind === 'function' ? expectedType.result : undefined : this.resolveTypeReference(expression.returnType, new Map());
+        if (!expression.expressionBody && expectedResult === undefined)
+            this.diagnostics.error('L2084', 'Block lambdas require a return type unless the expected function type supplies one', expression.span);
+        const effects = expression.effects.length > 0 ? expression.effects : expectedType?.kind === 'function' ? expectedType.effects : [];
+        const previous = this.#currentFunction;
+        const context = { declaration: expression, scope: child, async: expression.async, returnTypes: [], typeParameters: new Map(), effects: new Set(effects), ...(expectedResult === undefined ? {} : { returnType: expectedResult }) };
+        this.#currentFunction = context;
+        let result;
+        if (expression.expressionBody) {
+            result = this.checkExpression(expression.body, child, expectedResult);
+            context.returnTypes.push(result);
+        }
+        else {
+            this.checkBlock(expression.body, child);
+            result = expectedResult ?? this.commonType(context.returnTypes, expression.span);
+            const controlFlow = analyzeControlFlow(expression.body, this.arena);
+            if (result !== this.arena.unit && !controlFlow.alwaysTerminates)
+                this.diagnostics.error('L3001', 'Lambda does not return on every path', expression.span);
+            for (const span of controlFlow.unreachable)
+                this.diagnostics.error('L3006', 'Unreachable statement', span);
+        }
+        this.#currentFunction = previous;
+        if (expectedResult !== undefined && !this.isAssignable(result, expectedResult))
+            this.typeMismatch(result, expectedResult, expression.span);
+        return this.arena.function(parameters, expectedResult ?? result, [], expression.async, effects);
+    }
+    checkParallel(expression, scope) {
+        const fields = new Map();
+        let commonError;
+        for (const entry of expression.entries) {
+            if (fields.has(entry.name))
+                this.diagnostics.error('L2036', `Duplicate parallel entry ${entry.name}`, entry.span);
+            const futureId = this.checkExpression(entry.value, scope);
+            const future = this.arena.get(futureId);
+            if (future.kind !== 'future') {
+                this.diagnostics.error('L2037', 'parallel entries must be async expressions', entry.value.span);
+                fields.set(entry.name, this.arena.error);
+                continue;
+            }
+            if (expression.tryMode) {
+                const result = this.arena.get(future.value);
+                if (result.kind !== 'result') {
+                    this.diagnostics.error('L2038', 'parallel try entries must return Result', entry.value.span);
+                    fields.set(entry.name, this.arena.error);
+                    continue;
+                }
+                if (commonError !== undefined && !this.arena.equals(commonError, result.error))
+                    this.diagnostics.error('L2039', 'parallel try entries must share the same error type', entry.value.span);
+                commonError ??= result.error;
+                fields.set(entry.name, result.value);
+            }
+            else
+                fields.set(entry.name, future.value);
+        }
+        const record = this.arena.add({ kind: 'named', name: `$Parallel${expression.id}`, definitionId: `${this.#moduleId}#$Parallel${expression.id}`, declarationKind: 'record', arguments: [], fields });
+        return this.arena.future(expression.tryMode ? this.arena.result(record, commonError ?? this.arena.error) : record);
+    }
+    resolveTypeReference(reference, typeParameters) {
+        if (reference.functionType !== undefined) {
+            const functionType = reference.functionType;
+            this.validateEffects(functionType.effects, reference.span);
+            let resolved = this.arena.function(functionType.parameters.map(parameter => this.resolveTypeReference(parameter, typeParameters)), this.resolveTypeReference(functionType.result, typeParameters), [], functionType.async, functionType.effects);
+            if (reference.optional)
+                resolved = this.arena.option(resolved);
+            reference.resolvedTypeId = resolved;
+            return resolved;
+        }
+        let typeId = typeParameters.get(reference.name) ?? this.#namedTypes.get(reference.name);
+        if (typeId === undefined) {
+            const imported = this.globalScope.lookup(reference.name);
+            if (imported?.typeOnly === true) {
+                const importedType = this.arena.get(imported.typeId);
+                if (importedType.kind === 'foreign')
+                    typeId = imported.typeId;
+            }
+        }
+        const args = reference.arguments.map(item => this.resolveTypeReference(item, typeParameters));
+        if (reference.name === 'List')
+            typeId = args.length === 1 ? this.arena.list(args[0]) : this.invalidArity(reference, 1, args.length);
+        else if (reference.name === 'Map')
+            typeId = args.length === 2 ? this.arena.map(args[0], args[1]) : this.invalidArity(reference, 2, args.length);
+        else if (reference.name === 'Set')
+            typeId = args.length === 1 ? this.arena.set(args[0]) : this.invalidArity(reference, 1, args.length);
+        else if (reference.name === 'Option')
+            typeId = args.length === 1 ? this.arena.option(args[0]) : this.invalidArity(reference, 1, args.length);
+        else if (reference.name === 'Result')
+            typeId = args.length === 2 ? this.arena.result(args[0], args[1]) : this.invalidArity(reference, 2, args.length);
+        else if (reference.name === 'Validation')
+            typeId = args.length === 2 ? this.arena.result(args[0], this.arena.list(args[1])) : this.invalidArity(reference, 2, args.length);
+        else if (reference.name === '$Tuple')
+            typeId = args.length >= 2 ? this.arena.tuple(args) : this.invalidArity(reference, 2, args.length);
+        else if (reference.name === 'Stream')
+            typeId = args.length === 1 ? this.arena.add({ kind: 'named', name: 'Stream', definitionId: 'std:Stream', declarationKind: 'alias', arguments: [args[0]] }) : this.invalidArity(reference, 1, args.length);
+        else if (typeId === undefined) {
+            this.diagnostics.error('L2040', `Unknown type ${reference.name}`, reference.span);
+            typeId = this.arena.error;
+        }
+        else if (args.length > 0) {
+            const named = this.arena.get(typeId);
+            if (named.kind === 'named') {
+                const declaration = this.#recordDeclarations.get(reference.name) ?? this.#enumDeclarations.get(reference.name) ?? this.#typeAliasDeclarations.get(reference.name);
+                const parameters = declaration?.typeParameters ?? [];
+                if (parameters.length !== args.length)
+                    this.diagnostics.error('L2041', `${reference.name} expects ${parameters.length} type arguments, received ${args.length}`, reference.span);
+                const substitutions = new Map(parameters.map((item, index) => [item.name, args[index] ?? this.arena.error]));
+                typeId = this.arena.add({ ...named, arguments: args, ...(named.fields === undefined ? {} : { fields: new Map([...named.fields].map(([field, fieldType]) => [field, this.substitute(fieldType, substitutions)])) }), ...(named.variants === undefined ? {} : { variants: new Map([...named.variants].map(([variant, values]) => [variant, values.map(value => this.substitute(value, substitutions))])) }), ...(named.underlying === undefined ? {} : { underlying: this.substitute(named.underlying, substitutions) }) });
+            }
+        }
+        const resolvedNamed = this.arena.get(typeId);
+        if (resolvedNamed.kind === 'named' && resolvedNamed.declarationKind === 'alias' && resolvedNamed.underlying !== undefined)
+            typeId = resolvedNamed.underlying;
+        if (reference.optional)
+            typeId = this.arena.option(typeId);
+        reference.resolvedTypeId = typeId;
+        return typeId;
+    }
+    containsForeignType(typeId, seen = new Set()) {
+        if (seen.has(typeId))
+            return false;
+        seen.add(typeId);
+        const type = this.arena.get(typeId);
+        switch (type.kind) {
+            case 'foreign': return true;
+            case 'function': return type.parameters.some(item => this.containsForeignType(item, seen)) || this.containsForeignType(type.result, seen);
+            case 'list':
+            case 'set': return this.containsForeignType(type.element, seen);
+            case 'map': return this.containsForeignType(type.key, seen) || this.containsForeignType(type.value, seen);
+            case 'tuple': return type.items.some(item => this.containsForeignType(item, seen));
+            case 'option':
+            case 'future': return this.containsForeignType(type.value, seen);
+            case 'result': return this.containsForeignType(type.value, seen) || this.containsForeignType(type.error, seen);
+            case 'named': return type.arguments.some(item => this.containsForeignType(item, seen)) || (type.underlying !== undefined && this.containsForeignType(type.underlying, seen));
+            default: return false;
+        }
+    }
+    containsOpenEffect(typeId, seen = new Set()) {
+        if (seen.has(typeId))
+            return false;
+        seen.add(typeId);
+        const type = this.arena.get(typeId);
+        switch (type.kind) {
+            case 'function': return type.effects.includes('*') || type.parameters.some(item => this.containsOpenEffect(item, seen)) || this.containsOpenEffect(type.result, seen);
+            case 'list':
+            case 'set': return this.containsOpenEffect(type.element, seen);
+            case 'map': return this.containsOpenEffect(type.key, seen) || this.containsOpenEffect(type.value, seen);
+            case 'tuple': return type.items.some(item => this.containsOpenEffect(item, seen));
+            case 'option':
+            case 'future': return this.containsOpenEffect(type.value, seen);
+            case 'result': return this.containsOpenEffect(type.value, seen) || this.containsOpenEffect(type.error, seen);
+            case 'named': return type.arguments.some(item => this.containsOpenEffect(item, seen)) || (type.underlying !== undefined && this.containsOpenEffect(type.underlying, seen)) || [...(type.fields?.values() ?? [])].some(item => this.containsOpenEffect(item, seen)) || [...(type.variants?.values() ?? [])].flat().some(item => this.containsOpenEffect(item, seen));
+            default: return false;
+        }
+    }
+    isSafeFfiType(typeId, seen = new Set()) {
+        const type = this.arena.get(typeId);
+        if (type.kind === 'primitive')
+            return type.name !== 'Never' && type.name !== 'InvalidType';
+        if (seen.has(typeId))
+            return false;
+        seen.add(typeId);
+        switch (type.kind) {
+            case 'function':
+            case 'foreign':
+            case 'typeVariable': return false;
+            case 'list': return this.isSafeFfiType(type.element, seen);
+            case 'tuple': return type.items.every(item => this.isSafeFfiType(item, new Set(seen)));
+            case 'option':
+            case 'future': return this.isSafeFfiType(type.value, seen);
+            case 'result': return this.isSafeFfiType(type.value, new Set(seen)) && this.isSafeFfiType(type.error, new Set(seen));
+            case 'map': return this.isSafeFfiPrimitiveKey(type.key) && this.isSafeFfiType(type.value, seen);
+            case 'set': return this.isSafeFfiPrimitiveKey(type.element);
+            case 'named': {
+                if (type.arguments.some(item => this.arena.get(item).kind === 'typeVariable'))
+                    return false;
+                if (type.underlying !== undefined)
+                    return this.isSafeFfiType(type.underlying, seen);
+                if (type.fields !== undefined)
+                    return [...type.fields.values()].every(item => this.isSafeFfiType(item, new Set(seen)));
+                if (type.variants !== undefined)
+                    return [...type.variants.values()].flat().every(item => this.isSafeFfiType(item, new Set(seen)));
+                return false;
+            }
+        }
+    }
+    isSafeFfiPrimitiveKey(typeId) {
+        const type = this.arena.get(typeId);
+        return type.kind === 'primitive' && ['String', 'Int', 'BigInt', 'Bool'].includes(type.name);
+    }
+    invalidArity(reference, expected, actual) { this.diagnostics.error('L2041', `${reference.name} expects ${expected} type arguments, received ${actual}`, reference.span); return this.arena.error; }
+    isAssignable(source, target) { return this.#types.isAssignable(source, target); }
+    listElementOf(typeId) { return this.#types.listElementOf(typeId); }
+    setElementOf(typeId) { return this.#types.setElementOf(typeId); }
+    mapKeyOf(typeId) { return this.#types.mapKeyOf(typeId); }
+    isMustUse(typeId, seen = new Set()) { return this.#types.isMustUse(typeId, seen); }
+    supportsHash(typeId, seen = new Set()) { return this.#types.supportsHash(typeId, seen); }
+    containsTypeVariable(typeId, seen = new Set()) { return this.#types.containsTypeVariable(typeId, seen); }
+    supportsDerive(typeId, derive, seen = new Set()) { return this.#types.supportsDerive(typeId, derive, seen); }
+    supportsJson(typeId, seen = new Set()) { return this.#types.supportsJson(typeId, seen); }
+    supportsDerivedEq(typeId, owner, seen = new Set()) { return this.#types.supportsDerivedEq(typeId, owner, seen); }
+    supportsEq(typeId, seen = new Set()) { return this.#types.supportsEq(typeId, seen); }
+    commonType(types, span) { return this.#types.commonType(types, span); }
+    isConstantExpression(expression) {
+        switch (expression.kind) {
+            case 'LiteralExpression': return true;
+            case 'IdentifierExpression': return expression.symbolId !== undefined && this.#symbols.get(expression.symbolId)?.constant === true;
+            case 'UnaryExpression': return this.isConstantExpression(expression.operand);
+            case 'BinaryExpression': return this.isConstantExpression(expression.left) && this.isConstantExpression(expression.right);
+            case 'ListExpression':
+            case 'TupleExpression': return expression.items.every(item => this.isConstantExpression(item));
+            case 'RecordExpression': return expression.entries.every(entry => this.isConstantExpression(entry.value));
+            case 'ConditionalExpression': return this.isConstantExpression(expression.condition) && this.isConstantExpression(expression.thenExpression) && this.isConstantExpression(expression.elseExpression);
+            default: return false;
+        }
+    }
+    requireBool(typeId, span) { if (!this.arena.equals(typeId, this.arena.bool))
+        this.typeMismatch(typeId, this.arena.bool, span); }
+    typeMismatch(actual, expected, span) { this.diagnostics.error('L2043', `${this.arena.display(actual)} cannot be used as ${this.arena.display(expected)}`, span); }
+    unify(pattern, actual, substitutions) { this.#types.unify(pattern, actual, substitutions); }
+    substitute(typeId, substitutions) { return this.#types.substitute(typeId, substitutions); }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function hasExactEnumerableKeys(value, expected) {
+    const actual = Object.keys(value).sort(compareText);
+    const canonicalExpected = [...expected].sort(compareText);
+    return actual.length === canonicalExpected.length && actual.every((key, index) => key === canonicalExpected[index]);
+}
+function isContextualCallablePrimitive(value) {
+    return typeof value === 'string' && ['boolean', 'string', 'number', 'bigint', 'undefined'].includes(value);
+}
+function canonicalContextualCallableResult(value) {
+    if (!isRecord(value) || typeof value.kind !== 'string')
+        return undefined;
+    if (value.kind === 'void' || value.kind === 'external' || value.kind === 'deferred')
+        return hasExactEnumerableKeys(value, ['kind']) ? Object.freeze({ kind: value.kind }) : undefined;
+    if (value.kind === 'callable') {
+        if (!hasExactEnumerableKeys(value, ['callable', 'kind']) || !isRecord(value.callable) || !hasExactEnumerableKeys(value.callable, ['parameters', 'result']) || !Array.isArray(value.callable.parameters))
+            return undefined;
+        const parameters = [];
+        for (const parameter of value.callable.parameters) {
+            if (!isContextualCallablePrimitive(parameter))
+                return undefined;
+            parameters.push(parameter);
+        }
+        const result = canonicalContextualCallableResult(value.callable.result);
+        if (result === undefined || (result.kind !== 'void' && result.kind !== 'value'))
+            return undefined;
+        return Object.freeze({ kind: 'callable', callable: Object.freeze({ parameters: Object.freeze(parameters), result }) });
+    }
+    if (value.kind !== 'value' && value.kind !== 'promise')
+        return undefined;
+    if (!hasExactEnumerableKeys(value, ['kind', 'value']))
+        return undefined;
+    if (value.kind === 'promise' && value.value === 'void')
+        return Object.freeze({ kind: 'promise', value: 'void' });
+    if (!isContextualCallablePrimitive(value.value))
+        return undefined;
+    return value.kind === 'value'
+        ? Object.freeze({ kind: 'value', value: value.value })
+        : Object.freeze({ kind: 'promise', value: value.value });
+}
+function callableParameterMatchesContext(native, target) {
+    return native === 'Bool' ? target === 'boolean'
+        : native === 'String' ? target === 'string'
+            : native === 'Float' ? target === 'number'
+                : native === 'BigInt' ? target === 'bigint'
+                    : native === 'Unit' ? target === 'undefined'
+                        : false;
+}
+function callablePrimitiveExternalName(native) {
+    return native === 'Bool' ? 'boolean'
+        : native === 'String' ? 'string'
+            : native === 'Int' || native === 'Float' ? 'number'
+                : native === 'BigInt' ? 'bigint'
+                    : native === 'Unit' ? 'undefined'
+                        : undefined;
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareSemanticPoint(left, right) {
+    if (left.usageIndex !== right.usageIndex)
+        return left.usageIndex - right.usageIndex;
+    return left.order - right.order;
+}
+function stableForeignUsage(usage) {
+    const snapshot = usage.foreignType;
+    const foreignType = {
+        display: snapshot.display,
+        category: snapshot.category,
+        ...(snapshot.canonicalIdentity === undefined ? {} : { canonicalIdentity: snapshot.canonicalIdentity }),
+        ...(snapshot.primitive === undefined ? {} : { primitive: snapshot.primitive }),
+        ...(snapshot.mustUse === undefined ? {} : { mustUse: snapshot.mustUse }),
+        ...(snapshot.origin === undefined ? {} : { origin: snapshot.origin }),
+    };
+    return {
+        kind: usage.kind,
+        nodeId: usage.nodeId,
+        span: usage.span,
+        foreignType,
+        ...(usage.runtimeImport === undefined ? {} : { runtimeImport: usage.runtimeImport }),
+        ...(usage.moduleWitness === undefined ? {} : { moduleWitness: usage.moduleWitness }),
+        ...(usage.receiverMode === undefined ? {} : { receiverMode: usage.receiverMode }),
+        ...(usage.mayReject === undefined ? {} : { mayReject: usage.mayReject }),
+        ...(usage.property === undefined ? {} : { property: usage.property }),
+        ...(usage.bridge === undefined ? {} : { bridge: usage.bridge }),
+    };
+}
+export function checkModule(module, options = {}) { return new TypeChecker(options).check(module); }
+//# sourceMappingURL=checker.js.map