@virune/compiler 1.1.0-rc.0

package/dist/src/codegen/emitter.js

@@ -0,0 +1,1029 @@
+import { escapeTemplate, javascriptStringLiteral, panicEmitter, safeName } from './helpers.js';
+import { runtimeImportLines } from './runtime-imports.js';
+import { SourceWriter } from './writer.js';
+const nativeChildrenProperty = '$viruneChildren';
+export class JavaScriptEmitter {
+    #writer;
+    #semantic;
+    #source;
+    #outputFile;
+    #symbolNames = new Map();
+    #componentParameterReads = new Map();
+    #repetitionReads = new Map();
+    #repetitionHost;
+    #sourceMap;
+    #contextName = '$ctx';
+    #temporary = 0;
+    #currentAsync = false;
+    #deferStacks = [];
+    constructor(hir, source, outputFile, options = {}) {
+        this.#semantic = hir.semantic;
+        this.#source = source;
+        this.#outputFile = outputFile;
+        this.#repetitionHost = options.repetitionHost;
+        this.#sourceMap = options.sourceMap ?? true;
+        this.#writer = new SourceWriter(source, outputFile, options.sourcePath ?? source.path, options.sourcesContent ?? true);
+        for (const [id, symbol] of hir.semantic.symbols)
+            this.#symbolNames.set(id, safeName(symbol.name));
+    }
+    emit(module) {
+        this.#moduleDeclarations = module.declarations;
+        for (const declaration of module.declarations) {
+            if (declaration.kind === 'FunctionDeclaration' && declaration.symbolId !== undefined && declaration.attributes.some(item => item.name === 'jsExport'))
+                this.#symbolNames.set(declaration.symbolId, `$impl_${safeName(declaration.name)}`);
+        }
+        this.emitHeader(module);
+        for (const declaration of module.imports)
+            this.emitImport(declaration);
+        this.emitExternImports(module.declarations);
+        if (this.#repetitionHost !== undefined)
+            this.#writer.line(`import * as $viruneRepetitionHostModule from ${JSON.stringify(this.#repetitionHost.moduleSpecifier)};`);
+        if (module.imports.length > 0 || module.declarations.some(item => item.kind === 'ExternDeclaration') || this.#repetitionHost !== undefined)
+            this.#writer.line();
+        for (const declaration of module.declarations) {
+            this.emitDeclaration(declaration);
+            this.#writer.line();
+        }
+        const result = this.#writer.result();
+        return { code: this.#sourceMap ? `${result.code}//# sourceMappingURL=${this.outputMapName()}\n` : result.code, map: result.map };
+    }
+    emitHeader(module) {
+        const hasCallableProjection = (this.#semantic.interop.callableProjections?.length ?? 0) > 0 || (this.#semantic.interop.objectCallableProjections?.length ?? 0) > 0 || this.#semantic.frontendCallableProjections.length > 0;
+        for (const line of runtimeImportLines(module, hasCallableProjection))
+            this.#writer.line(line);
+        if (hasCallableProjection) {
+            this.#writer.line("const $viruneCallableShimCacheKey = '$virune.callable-shim.cache/v1';");
+            this.#writer.line('const $viruneCallableShimObject = ({}).constructor;');
+            this.#writer.line('function $viruneProjectCallable($fn, $descriptor, $factory) {');
+            this.#writer.indent(() => {
+                this.#writer.line('let $cache = $viruneCallableShimObject.getOwnPropertyDescriptor($fn, $viruneCallableShimCacheKey)?.value;');
+                this.#writer.line('if ($cache === undefined) {');
+                this.#writer.indent(() => {
+                    this.#writer.line('$cache = [];');
+                    this.#writer.line('$viruneCallableShimObject.defineProperty($fn, $viruneCallableShimCacheKey, { value: $cache, enumerable: false, configurable: false, writable: false });');
+                });
+                this.#writer.line('}');
+                this.#writer.line('for (const $entry of $cache) if ($entry[0] === $descriptor) return $entry[1];');
+                this.#writer.line('const $shim = $factory($fn);');
+                this.#writer.line('$cache.push([$descriptor, $shim]);');
+                this.#writer.line('return $shim;');
+            });
+            this.#writer.line('}');
+            this.#writer.line();
+        }
+    }
+    outputMapName() { return `${this.#outputFile.split(/[\\/]/u).at(-1) ?? 'module.js'}.map`; }
+    emitImport(declaration) {
+        if (declaration.typeOnly)
+            return;
+        const source = declaration.sourceKind === 'virune' && declaration.source.endsWith('.virune')
+            ? declaration.source.slice(0, -7) + '.js'
+            : declaration.sourceKind === 'javascript' && declaration.source.endsWith('.interop.ts')
+                ? declaration.source.slice(0, -3) + '.mjs'
+                : declaration.source;
+        this.#writer.mark(declaration.span);
+        if (declaration.defaultImport !== undefined) {
+            this.#writer.line(`import ${safeName(declaration.defaultImport)} from ${JSON.stringify(source)};`);
+            if (declaration.public)
+                this.#writer.line(`export { ${safeName(declaration.defaultImport)} };`);
+            return;
+        }
+        if (declaration.namespaceImport !== undefined) {
+            this.#writer.line(`import * as ${safeName(declaration.namespaceImport)} from ${JSON.stringify(source)};`);
+            if (declaration.public)
+                this.#writer.line(`export { ${safeName(declaration.namespaceImport)} };`);
+            return;
+        }
+        if (declaration.items.length === 0) {
+            this.#writer.line(`import ${JSON.stringify(source)};`);
+            return;
+        }
+        const items = declaration.items.map(item => item.imported === item.local ? item.imported : `${item.imported} as ${safeName(item.local)}`).join(', ');
+        this.#writer.line(`import { ${items} } from ${JSON.stringify(source)};`);
+        if (declaration.public)
+            this.#writer.line(`export { ${declaration.items.map(item => safeName(item.local)).join(', ')} };`);
+    }
+    emitExternImports(declarations) {
+        let index = 0;
+        for (const declaration of declarations) {
+            if (declaration.kind !== 'ExternDeclaration')
+                continue;
+            this.#writer.line(`import * as $ffi${index} from ${JSON.stringify(declaration.module)};`);
+            index++;
+        }
+    }
+    emitDeclaration(declaration) {
+        this.#writer.mark(declaration.span, 'name' in declaration ? declaration.name : undefined);
+        switch (declaration.kind) {
+            case 'FunctionDeclaration':
+                this.emitFunction(declaration);
+                break;
+            case 'ComponentDeclaration':
+                this.emitComponent(declaration);
+                break;
+            case 'RecordDeclaration':
+                this.emitRecordDeclaration(declaration);
+                break;
+            case 'EnumDeclaration':
+                this.emitEnumDeclaration(declaration);
+                break;
+            case 'NewtypeDeclaration':
+                this.emitNewtypeDeclaration(declaration);
+                break;
+            case 'TypeAliasDeclaration':
+                this.#writer.line(`// type ${declaration.name} is erased during JavaScript emission.`);
+                break;
+            case 'ExternDeclaration':
+                this.emitExternDeclaration(declaration);
+                break;
+            case 'TestDeclaration':
+                this.emitTest(declaration);
+                break;
+            case 'TopLevelLetDeclaration':
+                this.#writer.line(`${this.moduleExported(declaration) ? 'export ' : this.exportPrefix(declaration.attributes)}const ${this.nameOf(declaration.symbolId, declaration.name)} = ${this.expression(declaration.value)};`);
+                break;
+        }
+    }
+    emitRecordDeclaration(declaration) {
+        this.#writer.line(`// record ${declaration.name}`);
+        if (this.moduleExported(declaration))
+            this.#writer.line(`export const ${safeName(declaration.name)} = Object.freeze({ name: ${JSON.stringify(declaration.name)}, typeId: ${JSON.stringify(this.declarationTypeId(declaration.symbolId, declaration.definitionId ?? declaration.name))} });`);
+    }
+    emitEnumDeclaration(declaration) {
+        this.#writer.line(`// enum ${declaration.name}`);
+        for (const variant of declaration.variants) {
+            const prefix = this.moduleExported(declaration) ? 'export ' : '';
+            const name = this.nameOf(variant.symbolId, variant.name);
+            if (variant.values.length === 0)
+                this.#writer.line(`${prefix}const ${name} = Object.freeze(makeVariant(${JSON.stringify(variant.name)}, [], ${JSON.stringify(this.declarationTypeId(declaration.symbolId, declaration.definitionId ?? declaration.name))}));`);
+            else {
+                const args = variant.values.map((_, index) => `$value${index}`).join(', ');
+                this.#writer.line(`${prefix}function ${name}(${args}) { return makeVariant(${JSON.stringify(variant.name)}, [${args}], ${JSON.stringify(this.declarationTypeId(declaration.symbolId, declaration.definitionId ?? declaration.name))}); }`);
+            }
+        }
+        this.#writer.line(`${this.moduleExported(declaration) ? 'export ' : ''}const ${safeName(declaration.name)} = Object.freeze({ ${declaration.variants.map(variant => safeName(variant.name)).join(', ')} });`);
+    }
+    emitNewtypeDeclaration(declaration) {
+        const prefix = this.moduleExported(declaration) ? 'export ' : '';
+        this.#writer.line(`${prefix}const ${safeName(declaration.name)} = Object.freeze({ create: value => value });`);
+    }
+    emitFunction(declaration) {
+        const jsExport = declaration.attributes.some(item => item.name === 'jsExport');
+        const prefix = this.moduleExported(declaration) && !jsExport ? 'export ' : '';
+        const asyncKeyword = declaration.async ? 'async ' : '';
+        const name = this.nameOf(declaration.symbolId, declaration.name);
+        const parameters = declaration.parameters.map(parameter => this.nameOf(parameter.symbolId, parameter.name));
+        parameters.push('$ctx = rootTaskContext()');
+        this.#writer.line(`${prefix}${asyncKeyword}function ${name}(${parameters.join(', ')}) {`);
+        const previousAsync = this.#currentAsync;
+        const previousContextName = this.#contextName;
+        this.#currentAsync = declaration.async;
+        this.#contextName = '$ctx';
+        this.#writer.indent(() => {
+            this.#writer.line('try {');
+            this.#writer.indent(() => {
+                if (declaration.expressionBody)
+                    this.#writer.line(`return ${this.expression(declaration.body)};`);
+                else
+                    this.emitBlock(declaration.body);
+            });
+            this.#writer.line('} catch ($error) {');
+            this.#writer.indent(() => {
+                this.#writer.line('if (isPropagation($error)) return $error.value;');
+                this.#writer.line('throw $error;');
+            });
+            this.#writer.line('}');
+        });
+        this.#writer.line('}');
+        this.#currentAsync = previousAsync;
+        this.#contextName = previousContextName;
+        if (jsExport)
+            this.emitJsExportWrapper(declaration, name);
+    }
+    emitComponent(declaration) {
+        const prefix = this.moduleExported(declaration) ? 'export ' : '';
+        const name = this.nameOf(declaration.symbolId, declaration.name);
+        this.#componentParameterReads.clear();
+        for (const parameter of declaration.parameters) {
+            if (parameter.symbolId === undefined)
+                return panicEmitter(`Component parameter ${parameter.name} reached emission without a symbol`);
+            this.#componentParameterReads.set(parameter.symbolId, `$viruneValidateSafeFfiValue($props[${JSON.stringify(parameter.name)}], ${this.safeFfiBoundary(this.typeDescriptor(parameter.type))}, ${JSON.stringify(`$.${parameter.name}`)})`);
+        }
+        const previousAsync = this.#currentAsync;
+        const previousContextName = this.#contextName;
+        this.#currentAsync = false;
+        this.#contextName = '$ctx';
+        this.#writer.line(`${prefix}function ${name}($props) {`);
+        this.#writer.indent(() => {
+            this.#writer.line('const $ctx = rootTaskContext();');
+            this.#writer.line('try {');
+            this.#writer.indent(() => this.emitBlock(declaration.body));
+            this.#writer.line('} catch ($error) {');
+            this.#writer.indent(() => {
+                this.#writer.line('if (isPropagation($error)) return $error.value;');
+                this.#writer.line('throw $error;');
+            });
+            this.#writer.line('}');
+        });
+        this.#writer.line('}');
+        this.#currentAsync = previousAsync;
+        this.#contextName = previousContextName;
+        this.#componentParameterReads.clear();
+    }
+    emitJsExportWrapper(declaration, implementationName) {
+        const rawParameters = declaration.parameters.map(parameter => `$js_${safeName(parameter.name)}`);
+        this.#writer.line(`export ${declaration.async ? 'async ' : ''}function ${safeName(declaration.name)}(${rawParameters.join(', ')}) {`);
+        this.#writer.indent(() => {
+            const validated = declaration.parameters.map((parameter, index) => {
+                const local = `$arg_${safeName(parameter.name)}`;
+                this.#writer.line(`const ${local} = $viruneValidateSafeFfiValue(${rawParameters[index]}, ${this.safeFfiBoundary(this.typeDescriptor(parameter.type))}, ${JSON.stringify(`$.${parameter.name}`)});`);
+                return local;
+            });
+            const call = `${implementationName}(${[...validated, 'rootTaskContext()'].join(', ')})`;
+            this.#writer.line(`return $viruneEncodeSafeFfiValue(${declaration.async ? `await ${call}` : call}, ${this.safeFfiBoundary(this.typeDescriptor(declaration.returnType))});`);
+        });
+        this.#writer.line('}');
+    }
+    emitExternDeclaration(declaration) {
+        const externIndex = this.externIndex(declaration);
+        for (const fn of declaration.functions) {
+            const name = this.nameOf(fn.symbolId, fn.name);
+            const args = fn.parameters.map(parameter => this.nameOf(parameter.symbolId, parameter.name));
+            if (fn.async)
+                args.push('$ctx = rootTaskContext()');
+            const encoded = fn.parameters.map(parameter => declaration.unsafe
+                ? `encodeFfiValue(${this.nameOf(parameter.symbolId, parameter.name)}, ${this.typeDescriptor(parameter.type)})`
+                : `$viruneEncodeSafeFfiValue(${this.nameOf(parameter.symbolId, parameter.name)}, ${this.safeFfiBoundary(this.typeDescriptor(parameter.type))})`);
+            const optionalCount = [...fn.parameters].reverse().findIndex(parameter => !parameter.optional);
+            const trailingOptional = optionalCount < 0 ? fn.parameters.length : optionalCount;
+            const encodedArguments = encoded.join(', ');
+            const requiredCount = fn.parameters.length - trailingOptional;
+            const foreignMember = `$ffi${externIndex}[${javascriptStringLiteral(fn.jsName)}]`;
+            const directCall = `${foreignMember}(${encodedArguments})`;
+            const spreadCall = `${foreignMember}(...$args)`;
+            const argumentSetup = `const $args = [${encodedArguments}]; while ($args.length > ${requiredCount} && $args[$args.length - 1] === undefined) $args.pop();`;
+            if (declaration.unsafe) {
+                const body = trailingOptional === 0 ? `{ return ${directCall}; }` : `{ ${argumentSetup} return ${spreadCall}; }`;
+                this.#writer.line(`${fn.async ? 'async ' : ''}function ${name}(${args.join(', ')}) ${body}`);
+            }
+            else if (fn.async) {
+                const success = fn.returnType.name === 'Result' ? fn.returnType.arguments[0] : undefined;
+                const operation = trailingOptional === 0 ? `() => ${directCall}` : `() => { ${argumentSetup} return ${spreadCall}; }`;
+                this.#writer.line(`async function ${name}(${args.join(', ')}) { return safeCallAsync(${operation}, $value => $viruneValidateSafeFfiValue($value, ${this.safeFfiBoundary(this.typeDescriptor(success))}, '$')); }`);
+            }
+            else {
+                const success = fn.returnType.name === 'Result' ? fn.returnType.arguments[0] : undefined;
+                const descriptor = this.safeFfiBoundary(this.typeDescriptor(success));
+                const directValidated = `$viruneValidateSafeFfiValue(${directCall}, ${descriptor}, '$')`;
+                const spreadValidated = `$viruneValidateSafeFfiValue(${spreadCall}, ${descriptor}, '$')`;
+                const operation = trailingOptional === 0 ? `() => ${directValidated}` : `() => { ${argumentSetup} return ${spreadValidated}; }`;
+                this.#writer.line(`function ${name}(${args.join(', ')}) { return safeCall(${operation}); }`);
+            }
+        }
+    }
+    externIndex(target) {
+        let index = 0;
+        for (const declaration of this.currentModuleDeclarations()) {
+            if (declaration === target)
+                return index;
+            if (declaration.kind === 'ExternDeclaration')
+                index++;
+        }
+        return index;
+    }
+    #moduleDeclarations = [];
+    currentModuleDeclarations() { return this.#moduleDeclarations; }
+    emitTest(declaration) {
+        this.#writer.line(`test(${JSON.stringify(declaration.name)}, ${declaration.async ? 'async ' : ''}() => {`);
+        const previousAsync = this.#currentAsync;
+        this.#currentAsync = declaration.async;
+        this.#writer.indent(() => {
+            this.#writer.line('const $ctx = rootTaskContext();');
+            this.emitBlock(declaration.body);
+        });
+        this.#currentAsync = previousAsync;
+        this.#writer.line('});');
+    }
+    emitBlock(block) {
+        const hasDefer = block.statements.some(statement => statement.kind === 'DeferStatement');
+        if (!hasDefer) {
+            for (const statement of block.statements)
+                this.emitStatement(statement);
+            return;
+        }
+        const stack = `$defers${this.#temporary++}`;
+        const primary = `$primary${this.#temporary++}`;
+        this.#writer.line(`const ${stack} = [];`);
+        this.#writer.line(`let ${primary};`);
+        this.#writer.line('try {');
+        this.#deferStacks.push(stack);
+        this.#writer.indent(() => { for (const statement of block.statements)
+            this.emitStatement(statement); });
+        this.#deferStacks.pop();
+        this.#writer.line('} catch ($error) {');
+        this.#writer.indent(() => { this.#writer.line(`${primary} = $error;`); this.#writer.line('throw $error;'); });
+        this.#writer.line('} finally {');
+        this.#writer.indent(() => this.#writer.line(`${this.#currentAsync ? 'await runDefersAsync' : 'runDefers'}(${stack}, ${primary});`));
+        this.#writer.line('}');
+    }
+    emitStatement(statement) {
+        this.#writer.mark(statement.span);
+        switch (statement.kind) {
+            case 'LetStatement':
+                this.#writer.line(`${statement.mutable ? 'let' : 'const'} ${this.nameOf(statement.symbolId, statement.name)} = ${this.expression(statement.value)};`);
+                break;
+            case 'ReturnStatement':
+                this.#writer.line(statement.value === undefined ? 'return undefined;' : `return ${this.expression(statement.value)};`);
+                break;
+            case 'IfStatement':
+                this.emitIf(statement);
+                break;
+            case 'ForStatement': {
+                this.#writer.line(`for (const ${this.nameOf(statement.symbolId, statement.name)} of ${this.expression(statement.iterable)}) {`);
+                this.#writer.indent(() => this.emitBlock(statement.body));
+                this.#writer.line('}');
+                break;
+            }
+            case 'WhileStatement':
+                this.#writer.line(`while (${this.expression(statement.condition)}) {`);
+                this.#writer.indent(() => this.emitBlock(statement.body));
+                this.#writer.line('}');
+                break;
+            case 'AssignmentStatement':
+                if (statement.invalidTarget !== undefined)
+                    throw new Error('Invalid assignment target reached JavaScript emission');
+                this.#writer.line(`${this.nameOf(statement.targetSymbolId, statement.name)} = ${this.expression(statement.value)};`);
+                break;
+            case 'MemberAssignmentStatement':
+                if (statement.foreignWrite !== true)
+                    throw new Error('Unproven writable facet reached JavaScript emission');
+                this.#writer.line(`${this.expression(statement.target)}[${JSON.stringify(statement.field)}] = ${this.expression(statement.value)};`);
+                break;
+            case 'IndexAssignmentStatement':
+                if (statement.foreignWrite !== true)
+                    throw new Error('Unproven writable facet reached JavaScript emission');
+                this.#writer.line(`${this.expression(statement.target)}[${this.expression(statement.index)}] = ${this.expression(statement.value)};`);
+                break;
+            case 'DeferStatement': {
+                const stack = this.#deferStacks.at(-1);
+                if (stack === undefined)
+                    throw new Error('defer emitted outside deferred block');
+                this.#writer.line(`${stack}.push(${this.#currentAsync ? 'async ' : ''}() => ${this.expression(statement.expression)});`);
+                break;
+            }
+            case 'BreakStatement':
+                this.#writer.line('break;');
+                break;
+            case 'ContinueStatement':
+                this.#writer.line('continue;');
+                break;
+            case 'DiscardStatement':
+                this.#writer.line(`void ${this.expression(statement.expression)};`);
+                break;
+            case 'ExpressionStatement':
+                this.#writer.line(`${this.expression(statement.expression)};`);
+                break;
+        }
+    }
+    emitIf(statement) {
+        this.#writer.line(`if (${this.expression(statement.condition)}) {`);
+        this.#writer.indent(() => this.emitBlock(statement.thenBlock));
+        if (statement.elseBranch === undefined)
+            this.#writer.line('}');
+        else if (statement.elseBranch.kind === 'BlockStatement') {
+            this.#writer.line('} else {');
+            this.#writer.indent(() => this.emitBlock(statement.elseBranch));
+            this.#writer.line('}');
+        }
+        else {
+            this.#writer.line('} else {');
+            this.#writer.indent(() => this.emitIf(statement.elseBranch));
+            this.#writer.line('}');
+        }
+    }
+    expression(expression, contextName = this.#contextName) {
+        const raw = this.expressionRaw(expression, contextName);
+        switch (expression.foreignBridge) {
+            case 'string': return `checkForeignString(${raw})`;
+            case 'bool': return `checkForeignBool(${raw})`;
+            case 'float': return `checkForeignFloat(${raw})`;
+            case 'bigint': return `checkForeignBigInt(${raw})`;
+            case 'unit': return `(${raw}, undefined)`;
+            case 'unknown': return `$viruneValidateSafeFfiValue(${raw}, ${this.safeFfiBoundary(`{ kind: 'unknown' }`)})`;
+            default: return raw;
+        }
+    }
+    expressionRaw(expression, contextName = this.#contextName) {
+        switch (expression.kind) {
+            case 'LiteralExpression': return this.literal(expression);
+            case 'IdentifierExpression': return this.identifier(expression);
+            case 'WildcardExpression': return 'undefined';
+            case 'CallExpression': return this.call(expression, contextName);
+            case 'FieldExpression': return this.field(expression, contextName);
+            case 'IndexExpression':
+                if (expression.foreignIndex !== true)
+                    return panicEmitter('IndexExpression reached emission without a checked index facet');
+                return `${this.expression(expression.target, contextName)}[${this.expression(expression.index, contextName)}]`;
+            case 'BinaryExpression': return this.binary(expression, contextName);
+            case 'UnaryExpression': return expression.operator === '-' && expression.inferredTypeId === this.#semantic.arena.int ? `intNegate(${this.expression(expression.operand, contextName)})` : `(${expression.operator}${this.expression(expression.operand, contextName)})`;
+            case 'PipelineExpression': return panicEmitter('PipelineExpression should be lowered before emission');
+            case 'TryExpression': return `propagate(${this.expression(expression.operand, contextName)})`;
+            case 'AwaitExpression': return `(await ${this.expression(expression.operand, contextName)})`;
+            case 'RecordExpression': {
+                const type = expression.inferredTypeId === undefined ? undefined : this.#semantic.arena.get(expression.inferredTypeId);
+                const typeId = type?.kind === 'named' ? type.definitionId : expression.name;
+                return `makeRecord({ ${expression.entries.map(entry => `${safeName(entry.name)}: ${this.expression(entry.value, contextName)}`).join(', ')} }, ${javascriptStringLiteral(typeId)})`;
+            }
+            case 'RecordUpdateExpression': return `updateRecord(${this.expression(expression.base, contextName)}, { ${expression.entries.map(entry => `${safeName(entry.name)}: ${this.expression(entry.value, contextName)}`).join(', ')} })`;
+            case 'ContextualAggregateExpression': return this.contextualAggregate(expression, contextName);
+            case 'ListExpression': return `[${expression.items.map(item => this.expression(item, contextName)).join(', ')}]`;
+            case 'TupleExpression': return `[${expression.items.map(item => this.expression(item, contextName)).join(', ')}]`;
+            case 'ConditionalExpression': return `(${this.expression(expression.condition, contextName)} ? ${this.expression(expression.thenExpression, contextName)} : ${this.expression(expression.elseExpression, contextName)})`;
+            case 'MatchExpression': return this.match(expression, contextName);
+            case 'LambdaExpression': return this.lambdaExpression(expression, contextName);
+            case 'ParallelExpression': return this.parallelExpression(expression, contextName);
+            case 'ViewExpression': return this.viewBlockExpression(expression.body, contextName);
+        }
+    }
+    viewBlockExpression(block, contextName) {
+        if (block.children.length === 1)
+            return this.viewChildExpression(block.children[0], contextName);
+        return `<>${block.children.map(child => this.viewChild(child, contextName)).join('')}</>`;
+    }
+    viewBlockContents(block, contextName) {
+        return block.children.map(child => this.viewChild(child, contextName)).join('');
+    }
+    viewChild(child, contextName) {
+        switch (child.kind) {
+            case 'ViewTextChild': return `{${javascriptStringLiteral(child.value)}}`;
+            case 'ViewExpressionChild': return `{${this.expression(child.expression, contextName)}}`;
+            case 'ViewChildrenSlot': return `{${this.nativeChildrenSlotExpression()}}`;
+            case 'ViewElement': return this.viewElement(child, contextName);
+            case 'ViewConditional': return `{${this.viewConditionalExpression(child, contextName)}}`;
+            case 'ViewRepetition': return `{${this.viewRepetitionExpression(child)}}`;
+        }
+    }
+    viewChildExpression(child, contextName) {
+        switch (child.kind) {
+            case 'ViewTextChild': return javascriptStringLiteral(child.value);
+            case 'ViewExpressionChild': return this.expression(child.expression, contextName);
+            case 'ViewChildrenSlot': return this.nativeChildrenSlotExpression();
+            case 'ViewElement': return this.viewElement(child, contextName);
+            case 'ViewConditional': return `(${this.viewConditionalExpression(child, contextName)})`;
+            case 'ViewRepetition': return this.viewRepetitionExpression(child);
+        }
+    }
+    nativeChildrenSlotExpression() {
+        return `(() => { const $slot = $props[${javascriptStringLiteral(nativeChildrenProperty)}]; return $slot === undefined ? <></> : $slot(); })()`;
+    }
+    viewElement(element, contextName) {
+        const tag = element.tag.join('.');
+        const root = element.tag[0];
+        const native = element.tag.length === 1 && root !== undefined && this.#semantic.globalScope.lookup(root)?.kind === 'component';
+        const properties = element.properties.map((property, propertyIndex) => `${property.name}={${native ? this.nativeComponentPropertyValue(property.value, contextName) : this.frontendViewPropertyValue(element.id, propertyIndex, property, contextName)}}`);
+        if (native && element.children !== undefined)
+            properties.push(`${nativeChildrenProperty}={() => ${this.viewBlockExpression(element.children, contextName)}}`);
+        const attributes = properties.length === 0 ? '' : ` ${properties.join(' ')}`;
+        if (element.children === undefined || native)
+            return `<${tag}${attributes} />`;
+        return `<${tag}${attributes}>${this.viewBlockContents(element.children, contextName)}</${tag}>`;
+    }
+    frontendViewPropertyValue(elementId, propertyIndex, property, contextName) {
+        const projection = this.#semantic.frontendCallableProjections.find(item => item.viewElementNodeId === elementId && item.propertyIndex === propertyIndex && item.property === property.name);
+        if (projection?.viewCallback !== undefined) {
+            if (property.value.kind !== 'LambdaExpression' || !property.value.expressionBody || property.value.body.kind !== 'ViewExpression')
+                return panicEmitter('View callback projection reached emission without a direct View lambda');
+            const raw = this.lambdaExpression(property.value, contextName, true);
+            return this.frontendViewCallbackProjection(raw, projection.viewCallback);
+        }
+        const descriptor = projection?.descriptor;
+        const projectedSyncExternal = property.value.kind === 'LambdaExpression' && descriptor?.async === false;
+        const raw = projectedSyncExternal ? this.lambdaExpression(property.value, contextName, true) : this.expression(property.value, contextName);
+        return descriptor === undefined ? raw : this.callableProjection(raw, descriptor);
+    }
+    nativeComponentPropertyValue(expression, contextName) {
+        const value = this.expression(expression, contextName);
+        const typeId = expression.inferredTypeId;
+        if (typeId === undefined)
+            return value;
+        const type = this.#semantic.arena.get(typeId);
+        if (type.kind !== 'named' || type.declarationKind !== 'record')
+            return value;
+        return `encodeFfiValue(${value}, ${this.safeFfiBoundary(this.typeDescriptorFromTypeId(typeId))})`;
+    }
+    viewConditionalExpression(conditional, contextName) {
+        const thenBranch = this.viewBlockExpression(conditional.thenBlock, contextName);
+        const elseBranch = conditional.elseBranch === undefined
+            ? '<></>'
+            : conditional.elseBranch.kind === 'ViewBlock'
+                ? this.viewBlockExpression(conditional.elseBranch, contextName)
+                : `(${this.viewConditionalExpression(conditional.elseBranch, contextName)})`;
+        return `${this.expression(conditional.condition, contextName)} ? ${thenBranch} : ${elseBranch}`;
+    }
+    checkedViewRepetitionEvidence(repetition) {
+        const evidence = repetition.checkedEvidence;
+        if (evidence === undefined || (repetition.indexName === undefined) !== (evidence.indexSymbolId === undefined))
+            return panicEmitter('View repetition reached emission without matching checked repetition evidence');
+        return evidence;
+    }
+    viewRepetitionExpression(repetition) {
+        this.checkedViewRepetitionEvidence(repetition);
+        if (this.#repetitionHost === undefined)
+            return panicEmitter('View repetition reached emission without a project Repetition Host binding');
+        return this.hostViewRepetitionExpression(repetition);
+    }
+    hostViewRepetitionExpression(repetition) {
+        const evidence = this.checkedViewRepetitionEvidence(repetition);
+        const identity = repetition.identity;
+        if (this.#repetitionHost === undefined)
+            return panicEmitter('Host View repetition reached emission without Host binding');
+        const identityType = identity.inferredTypeId === undefined ? undefined : this.#semantic.arena.get(identity.inferredTypeId);
+        if (identityType?.kind !== 'primitive' || (identityType.name !== 'String' && identityType.name !== 'Int'))
+            return panicEmitter('Host View repetition identity reached emission without checked String or Int evidence');
+        const sourceName = `$viewSource${this.#temporary++}`;
+        const lengthName = `$viewLength${this.#temporary++}`;
+        const sourceIndexName = `$viewIndex${this.#temporary++}`;
+        const itemName = this.nameOf(evidence.itemSymbolId, repetition.itemName);
+        const indexName = repetition.indexName === undefined ? undefined : this.nameOf(evidence.indexSymbolId, repetition.indexName);
+        const identitySeenName = `$viewIdentitySeen${this.#temporary++}`;
+        const identityName = `$viewIdentity${this.#temporary++}`;
+        const entriesName = `$viewEntries${this.#temporary++}`;
+        const snapshotContextName = `$viewSnapshotCtx${this.#temporary++}`;
+        const readValueName = `$viewReadValue${this.#temporary++}`;
+        const readIndexName = `$viewReadIndex${this.#temporary++}`;
+        const groupIdentityName = `$viewGroupIdentity${this.#temporary++}`;
+        const bodyContextName = `$viewBodyCtx${this.#temporary++}`;
+        const tag = identityType.name === 'String' ? 's:' : 'i:';
+        const lines = [
+            `$viruneRepetitionHostModule[${javascriptStringLiteral(this.#repetitionHost.exportName)}](`,
+            '\t() => {',
+            `\t\tconst ${snapshotContextName} = rootTaskContext();`,
+            `\t\tconst ${sourceName} = ${this.expression(repetition.source, snapshotContextName)};`,
+            `\t\tconst ${lengthName} = ${sourceName}.length;`,
+            `\t\tconst ${identitySeenName} = new Set();`,
+            `\t\tconst ${entriesName} = [];`,
+            `\t\tfor (let ${sourceIndexName} = 0; ${sourceIndexName} < ${lengthName}; ${sourceIndexName}++) {`,
+        ];
+        if (evidence.sourceKind === 'external-array')
+            lines.push(`\t\t\tif (!Object.prototype.hasOwnProperty.call(${sourceName}, ${sourceIndexName})) continue;`);
+        lines.push(`\t\t\tconst ${itemName} = ${sourceName}[${sourceIndexName}];`);
+        if (indexName !== undefined)
+            lines.push(`\t\t\tconst ${indexName} = ${sourceIndexName};`);
+        lines.push(`\t\t\tconst ${identityName} = ${JSON.stringify(tag)} + (${this.expression(identity, snapshotContextName)});`);
+        lines.push(`\t\t\tif (${identitySeenName}.has(${identityName})) throw new Error('Duplicate View repetition identity');`);
+        lines.push(`\t\t\t${identitySeenName}.add(${identityName});`);
+        lines.push(`\t\t\t${entriesName}.push({ id: ${identityName}, index: ${sourceIndexName}, value: ${itemName} });`);
+        lines.push('\t\t}', `\t\treturn ${entriesName};`, '\t},');
+        const previousItem = this.#repetitionReads.get(evidence.itemSymbolId);
+        const hadItem = this.#repetitionReads.has(evidence.itemSymbolId);
+        this.#repetitionReads.set(evidence.itemSymbolId, `${readValueName}()`);
+        let previousIndex;
+        let hadIndex = false;
+        if (evidence.indexSymbolId !== undefined) {
+            previousIndex = this.#repetitionReads.get(evidence.indexSymbolId);
+            hadIndex = this.#repetitionReads.has(evidence.indexSymbolId);
+            this.#repetitionReads.set(evidence.indexSymbolId, `${readIndexName}()`);
+        }
+        const body = this.viewBlockExpression(repetition.body, bodyContextName);
+        if (hadItem)
+            this.#repetitionReads.set(evidence.itemSymbolId, previousItem);
+        else
+            this.#repetitionReads.delete(evidence.itemSymbolId);
+        if (evidence.indexSymbolId !== undefined) {
+            if (hadIndex)
+                this.#repetitionReads.set(evidence.indexSymbolId, previousIndex);
+            else
+                this.#repetitionReads.delete(evidence.indexSymbolId);
+        }
+        lines.push(`\t(${readValueName}, ${readIndexName}, ${groupIdentityName}) => {`, `\t\tconst ${bodyContextName} = rootTaskContext();`, `\t\treturn ${body};`, '\t},', ')');
+        return lines.join('\n');
+    }
+    contextualAggregate(expression, contextName) {
+        if (expression.foreignObject !== true)
+            return panicEmitter('ContextualAggregateExpression reached emission without a checked aggregate facet');
+        const entries = expression.entries.map((entry, index) => {
+            const projection = this.#semantic.interop.objectCallableProjections?.find(item => item.objectNodeId === expression.id && item.entryIndex === index && item.property === entry.name);
+            const projectedSyncExternal = entry.value.kind === 'LambdaExpression' && projection?.descriptor.version === 'virune-callable-shim/v2' && projection.descriptor.async === false;
+            const raw = projectedSyncExternal ? this.lambdaExpression(entry.value, contextName, true) : this.expression(entry.value, contextName);
+            const value = projection === undefined ? raw : this.callableProjection(raw, projection.descriptor);
+            return `[${JSON.stringify(entry.name)}]: ${value}`;
+        });
+        return `({ ${entries.join(', ')} })`;
+    }
+    lambdaExpression(expression, outerContextName, forceProjectedSyncExternal = false) {
+        const parameters = expression.parameters.map(parameter => this.nameOf(parameter.symbolId, parameter.name));
+        const projectedSyncExternal = !expression.async && (forceProjectedSyncExternal || this.#semantic.interop.callableProjections?.some(item => item.nodeId === expression.id && item.descriptor.async === false) === true);
+        const ownsContext = expression.async || projectedSyncExternal;
+        const contextName = ownsContext ? `$lambdaCtx${this.#temporary++}` : outerContextName;
+        if (ownsContext)
+            parameters.push(`${contextName} = rootTaskContext()`);
+        const lines = [`${expression.async ? 'async ' : ''}(${parameters.join(', ')}) => {`, '\ttry {'];
+        if (expression.expressionBody)
+            lines.push(`\t\treturn ${this.expression(expression.body, contextName)};`);
+        else
+            lines.push(...this.inlineBlock(expression.body, contextName, expression.async, 2));
+        lines.push('\t} catch ($error) {', '\t\tif (isPropagation($error)) return $error.value;', '\t\tthrow $error;', '\t}', '}');
+        return `(${lines.join('\n')})`;
+    }
+    inlineBlock(block, contextName, async, indent) {
+        const prefix = '\t'.repeat(indent);
+        const hasDefer = block.statements.some(statement => statement.kind === 'DeferStatement');
+        if (!hasDefer)
+            return block.statements.flatMap(statement => this.inlineStatement(statement, contextName, async, indent));
+        const stack = `$lambdaDefers${this.#temporary++}`;
+        const primary = `$lambdaPrimary${this.#temporary++}`;
+        const lines = [`${prefix}const ${stack} = [];`, `${prefix}let ${primary};`, `${prefix}try {`];
+        for (const statement of block.statements)
+            lines.push(...this.inlineStatement(statement, contextName, async, indent + 1, stack));
+        lines.push(`${prefix}} catch ($error) {`, `${prefix}\t${primary} = $error;`, `${prefix}\tthrow $error;`, `${prefix}} finally {`, `${prefix}\t${async ? 'await runDefersAsync' : 'runDefers'}(${stack}, ${primary});`, `${prefix}}`);
+        return lines;
+    }
+    inlineStatement(statement, contextName, async, indent, deferStack) {
+        const prefix = '\t'.repeat(indent);
+        switch (statement.kind) {
+            case 'LetStatement': return [`${prefix}${statement.mutable ? 'let' : 'const'} ${this.nameOf(statement.symbolId, statement.name)} = ${this.expression(statement.value, contextName)};`];
+            case 'ReturnStatement': return [`${prefix}${statement.value === undefined ? 'return undefined;' : `return ${this.expression(statement.value, contextName)};`}`];
+            case 'AssignmentStatement':
+                if (statement.invalidTarget !== undefined)
+                    throw new Error('Invalid assignment target reached JavaScript emission');
+                return [`${prefix}${this.nameOf(statement.targetSymbolId, statement.name)} = ${this.expression(statement.value, contextName)};`];
+            case 'MemberAssignmentStatement':
+                if (statement.foreignWrite !== true)
+                    throw new Error('Unproven writable facet reached JavaScript emission');
+                return [`${prefix}${this.expression(statement.target, contextName)}[${JSON.stringify(statement.field)}] = ${this.expression(statement.value, contextName)};`];
+            case 'IndexAssignmentStatement':
+                if (statement.foreignWrite !== true)
+                    throw new Error('Unproven writable facet reached JavaScript emission');
+                return [`${prefix}${this.expression(statement.target, contextName)}[${this.expression(statement.index, contextName)}] = ${this.expression(statement.value, contextName)};`];
+            case 'BreakStatement': return [`${prefix}break;`];
+            case 'ContinueStatement': return [`${prefix}continue;`];
+            case 'DiscardStatement': return [`${prefix}void ${this.expression(statement.expression, contextName)};`];
+            case 'ExpressionStatement': return [`${prefix}${this.expression(statement.expression, contextName)};`];
+            case 'DeferStatement': {
+                if (deferStack === undefined)
+                    throw new Error('defer emitted without an inline defer stack');
+                return [`${prefix}${deferStack}.push(${async ? 'async ' : ''}() => ${this.expression(statement.expression, contextName)});`];
+            }
+            case 'WhileStatement': return [`${prefix}while (${this.expression(statement.condition, contextName)}) {`, ...this.inlineBlock(statement.body, contextName, async, indent + 1), `${prefix}}`];
+            case 'ForStatement': return [`${prefix}for (const ${this.nameOf(statement.symbolId, statement.name)} of ${this.expression(statement.iterable, contextName)}) {`, ...this.inlineBlock(statement.body, contextName, async, indent + 1), `${prefix}}`];
+            case 'IfStatement': return this.inlineIf(statement, contextName, async, indent);
+        }
+    }
+    inlineIf(statement, contextName, async, indent) {
+        const prefix = '\t'.repeat(indent);
+        const lines = [`${prefix}if (${this.expression(statement.condition, contextName)}) {`, ...this.inlineBlock(statement.thenBlock, contextName, async, indent + 1)];
+        if (statement.elseBranch === undefined)
+            return [...lines, `${prefix}}`];
+        if (statement.elseBranch.kind === 'BlockStatement')
+            return [...lines, `${prefix}} else {`, ...this.inlineBlock(statement.elseBranch, contextName, async, indent + 1), `${prefix}}`];
+        return [...lines, `${prefix}} else {`, ...this.inlineIf(statement.elseBranch, contextName, async, indent + 1), `${prefix}}`];
+    }
+    literal(expression) {
+        if (expression.literalKind === 'String')
+            return this.interpolatedString(expression.value);
+        if (expression.literalKind === 'BigInt')
+            return `${String(expression.value)}n`;
+        return String(expression.value);
+    }
+    interpolatedString(value) {
+        const placeholder = /(?<!\{)\{([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\}(?!\})/gu;
+        if (!placeholder.test(value))
+            return javascriptStringLiteral(value.replaceAll('{{', '{').replaceAll('}}', '}'));
+        placeholder.lastIndex = 0;
+        let result = '`';
+        let cursor = 0;
+        for (const match of value.matchAll(placeholder)) {
+            result += escapeTemplate(value.slice(cursor, match.index).replaceAll('{{', '{').replaceAll('}}', '}'));
+            result += `\${${match[1]}}`;
+            cursor = (match.index ?? 0) + match[0].length;
+        }
+        result += `${escapeTemplate(value.slice(cursor).replaceAll('{{', '{').replaceAll('}}', '}'))}\``;
+        return result;
+    }
+    identifier(expression) {
+        if (expression.symbolId !== undefined) {
+            const repetitionRead = this.#repetitionReads.get(expression.symbolId);
+            if (repetitionRead !== undefined)
+                return repetitionRead;
+            const componentRead = this.#componentParameterReads.get(expression.symbolId);
+            if (componentRead !== undefined)
+                return componentRead;
+        }
+        if (expression.name === 'Unit')
+            return 'undefined';
+        if (expression.name === 'expect')
+            return '$viruneExpect';
+        if (['Some', 'None', 'Ok', 'Err', 'panic'].includes(expression.name))
+            return expression.name;
+        return this.nameOf(expression.symbolId, expression.name);
+    }
+    call(expression, contextName) {
+        const foreignInvocation = expression.foreignCall === true || expression.foreignConstruct === true;
+        const args = expression.arguments.map((argument, index) => {
+            const raw = this.expression(argument, contextName);
+            const type = argument.inferredTypeId === undefined ? undefined : this.#semantic.arena.get(argument.inferredTypeId);
+            const guarded = foreignInvocation && type?.kind === 'primitive' && type.name === 'Unknown'
+                ? `$viruneEncodeSafeFfiValue(${raw}, ${this.safeFfiBoundary(`{ kind: 'unknown' }`)})`
+                : raw;
+            const projection = this.#semantic.interop.callableProjections?.find(item => item.callNodeId === expression.id && item.argumentIndex === index);
+            return projection === undefined ? guarded : this.callableProjection(guarded, projection.descriptor);
+        });
+        if (expression.callee.kind === 'FieldExpression' && expression.callee.target.kind === 'IdentifierExpression' && expression.callee.target.name === 'Json') {
+            if (expression.callee.field === 'parse')
+                return `parseJson(${args[0] ?? '""'})`;
+            if (expression.callee.field === 'decode') {
+                const result = expression.inferredTypeId === undefined ? undefined : this.#semantic.arena.get(expression.inferredTypeId);
+                const target = result?.kind === 'result' ? result.value : this.#semantic.arena.unknown;
+                return `decodeJsonValue(${args[0] ?? 'undefined'}, ${this.typeDescriptorFromTypeId(target)})`;
+            }
+            if (expression.callee.field === 'encode') {
+                const target = expression.arguments[0]?.inferredTypeId ?? this.#semantic.arena.unknown;
+                return `encodeJsonValue(${args[0] ?? 'undefined'}, ${this.typeDescriptorFromTypeId(target)})`;
+            }
+        }
+        const callee = this.expression(expression.callee, contextName);
+        if (expression.foreignConstruct === true)
+            return `new (${callee})(${args.join(', ')})`;
+        if (expression.foreignCall !== true && this.acceptsTaskContext(expression.callee))
+            args.push(contextName);
+        if (callee === '$viruneExpect')
+            return `(${args[0] ?? 'false'} ? undefined : panic('Expectation failed'))`;
+        return `${callee}(${args.join(', ')})`;
+    }
+    frontendViewCallbackProjection(callable, evidence) {
+        const rawParameters = Array.from({ length: evidence.parameterCount }, (_, index) => `$raw${index}`);
+        const invocation = `$fn(${[...rawParameters, 'rootTaskContext()'].join(', ')})`;
+        const wrapper = `(${rawParameters.join(', ')}) => { try { return ${invocation}; } catch ($error) { throw $viruneExternalizeInteropError($error); } }`;
+        const descriptorKey = JSON.stringify({ version: 'virune-frontend-view-callback/v1', parameterCount: evidence.parameterCount, effects: evidence.effects });
+        return `$viruneProjectCallable(${callable}, ${javascriptStringLiteral(descriptorKey)}, $fn => (${wrapper}))`;
+    }
+    callableProjection(callable, descriptor) {
+        const rawParameters = descriptor.parameters.map((_, index) => `$raw${index}`);
+        let body;
+        if (descriptor.version === 'virune-callable-shim/v1') {
+            const validated = descriptor.parameters.map((parameter, index) => `validateFfiValue(${rawParameters[index]}, ${this.callableFfiDescriptor(parameter)}, ${javascriptStringLiteral(`$[${index}]`)})`);
+            const invocation = `$fn(${[...validated, 'rootTaskContext()'].join(', ')})`;
+            const result = descriptor.async ? `await ${invocation}` : invocation;
+            body = `return encodeFfiValue(${result}, ${this.callableFfiDescriptor(descriptor.result)});`;
+        }
+        else if (descriptor.version === 'virune-callable-shim/v3') {
+            const validated = descriptor.parameters.map((parameter, index) => `validateFfiValue(${rawParameters[index]}, ${this.callableFfiDescriptor(parameter)}, ${javascriptStringLiteral(`$[${index}]`)})`);
+            const invocation = `$fn(${[...validated, 'rootTaskContext()'].join(', ')})`;
+            body = `const $result = ${invocation}; return ${this.callableProjection('$result', descriptor.result)};`;
+        }
+        else {
+            const invocation = `$fn(${[...rawParameters, 'rootTaskContext()'].join(', ')})`;
+            const result = descriptor.async ? `await ${invocation}` : invocation;
+            body = descriptor.result === 'Never'
+                ? `${result}; throw new Error("Virune Never callback returned unexpectedly");`
+                : `return ${result};`;
+        }
+        const wrapper = `${descriptor.async ? 'async ' : ''}(${rawParameters.join(', ')}) => { try { ${body} } catch ($error) { throw $viruneExternalizeInteropError($error); } }`;
+        const descriptorKey = JSON.stringify(descriptor);
+        return `$viruneProjectCallable(${callable}, ${javascriptStringLiteral(descriptorKey)}, $fn => (${wrapper}))`;
+    }
+    callableFfiDescriptor(primitive) {
+        switch (primitive) {
+            case 'Bool': return `{ kind: 'bool' }`;
+            case 'Int': return `{ kind: 'int' }`;
+            case 'Float': return `{ kind: 'float' }`;
+            case 'BigInt': return `{ kind: 'bigint' }`;
+            case 'String': return `{ kind: 'string' }`;
+            case 'Unit': return `{ kind: 'undefined' }`;
+        }
+    }
+    field(expression, contextName) {
+        if (expression.target.kind === 'IdentifierExpression') {
+            const key = `${expression.target.name}.${expression.field}`;
+            const mapped = {
+                'Console.print': 'console.log', 'Int.toFloat': 'Number', 'Float.toInt': 'floatToInt',
+                'Duration.milliseconds': 'durationMilliseconds', 'Duration.seconds': 'durationSeconds', 'Duration.minutes': 'durationMinutes', 'Duration.hours': 'durationHours', 'Duration.toMilliseconds': 'durationToMilliseconds',
+                'List.length': 'listLength', 'List.isEmpty': 'listIsEmpty', 'List.isNotEmpty': 'listIsNotEmpty', 'List.first': 'listFirst', 'List.last': 'listLast', 'List.get': 'listGet',
+                'List.append': 'listAppend', 'List.prepend': 'listPrepend', 'List.concat': 'listConcat', 'List.take': 'listTake', 'List.drop': 'listDrop', 'List.reverse': 'listReverse',
+                'List.map': 'listMap', 'List.flatMap': 'listFlatMap', 'List.filter': 'listFilter', 'List.find': 'listFind', 'List.any': 'listAny', 'List.all': 'listAll', 'List.fold': 'listFold', 'List.zip': 'listZip', 'List.enumerate': 'listEnumerate', 'List.unique': 'listUnique', 'List.uniqueBy': 'listUniqueBy',
+                'Map.empty': 'mapEmpty', 'Map.get': 'mapGet', 'Map.set': 'mapSet', 'Map.has': 'mapHas', 'Map.remove': 'mapRemove', 'Map.size': 'mapSize', 'Map.keys': 'mapKeys', 'Map.values': 'mapValues', 'Map.entries': 'mapEntries', 'Map.merge': 'mapMerge', 'Map.mapValues': 'mapMapValues',
+                'Set.empty': 'setEmpty', 'Set.from': 'setFrom', 'Set.add': 'setAdd', 'Set.has': 'setHas', 'Set.remove': 'setRemove', 'Set.size': 'setSize', 'Set.toList': 'setToList', 'Set.union': 'setUnion', 'Set.intersection': 'setIntersection', 'Set.difference': 'setDifference',
+                'Queue.empty': 'queueEmpty', 'Queue.enqueue': 'queueEnqueue', 'Queue.dequeue': 'queueDequeue', 'Stack.empty': 'stackEmpty', 'Stack.push': 'stackPush', 'Stack.pop': 'stackPop',
+                'String.codePoints': 'stringCodePoints', 'String.graphemes': 'stringGraphemes', 'String.graphemeLength': 'stringGraphemeLength', 'String.normalizeNfc': 'stringNormalizeNfc', 'String.normalizeNfd': 'stringNormalizeNfd', 'String.normalizeNfkc': 'stringNormalizeNfkc', 'String.normalizeNfkd': 'stringNormalizeNfkd', 'String.length': 'stringLength', 'String.trim': 'stringTrim', 'String.trimStart': 'stringTrimStart', 'String.trimEnd': 'stringTrimEnd', 'String.contains': 'stringContains', 'String.startsWith': 'stringStartsWith', 'String.endsWith': 'stringEndsWith', 'String.toLowerCase': 'stringToLowerCase', 'String.toUpperCase': 'stringToUpperCase', 'String.split': 'stringSplit', 'String.slice': 'stringSlice', 'String.join': 'stringJoin', 'String.replace': 'stringReplace', 'String.at': 'stringAt', 'String.isEmpty': 'stringIsEmpty', 'String.isNotEmpty': 'stringIsNotEmpty',
+                'ByteOrder.BigEndian': JSON.stringify('BigEndian'), 'ByteOrder.LittleEndian': JSON.stringify('LittleEndian'), 'HttpBody.Empty': "makeVariant('Empty', [], 'std:HttpBody')", 'HttpBody.Text': "(value => makeVariant('Text', [value], 'std:HttpBody'))", 'HttpBody.Bytes': "(value => makeVariant('Bytes', [value], 'std:HttpBody'))", 'Bytes.empty': 'bytesEmpty', 'Bytes.length': 'bytesLength', 'Bytes.fromUtf8': 'bytesFromUtf8', 'Bytes.toUtf8': 'bytesToUtf8', 'Bytes.fromHex': 'bytesFromHex', 'Bytes.toHex': 'bytesToHex', 'Bytes.fromBase64': 'bytesFromBase64', 'Bytes.toBase64': 'bytesToBase64', 'Bytes.concat': 'bytesConcat', 'Bytes.slice': 'bytesSlice', 'Bytes.get': 'bytesGet', 'Bytes.set': 'bytesSet', 'Bytes.readInt32': 'bytesReadInt32', 'Bytes.writeInt32': 'bytesWriteInt32', 'MutableBytes.create': 'mutableBytesCreate', 'MutableBytes.fromBytes': 'mutableBytesFromBytes', 'MutableBytes.toBytes': 'mutableBytesToBytes', 'MutableBytes.length': 'mutableBytesLength', 'MutableBytes.get': 'mutableBytesGet', 'MutableBytes.set': 'mutableBytesSet', 'MutableBytes.fill': 'mutableBytesFill', 'Byte.fromInt': 'byteCreate', 'Int8.fromInt': 'int8Create', 'Int8.toInt': 'int8ToInt', 'UInt8.fromInt': 'uint8Create', 'UInt8.toInt': 'uint8ToInt', 'Int16.fromInt': 'int16Create', 'Int16.toInt': 'int16ToInt', 'UInt16.fromInt': 'uint16Create', 'UInt16.toInt': 'uint16ToInt', 'Int32.fromInt': 'int32Create', 'Int32.toInt': 'int32ToInt', 'UInt32.fromInt': 'uint32Create', 'UInt32.toInt': 'uint32ToInt', 'Int64.fromBigInt': 'int64Create', 'Int64.toBigInt': 'int64ToBigInt', 'UInt64.fromBigInt': 'uint64Create', 'UInt64.toBigInt': 'uint64ToBigInt',
+                'Debug.format': 'debugValue',
+                'Option.map': 'optionMap', 'Option.andThen': 'optionAndThen', 'Option.filter': 'optionFilter', 'Option.unwrapOr': 'optionUnwrapOr', 'Option.toResult': 'optionToResult', 'Option.collect': 'optionCollect',
+                'Result.map': 'resultMap', 'Result.mapError': 'resultMapError', 'Result.andThen': 'resultAndThen', 'Result.orElse': 'resultOrElse', 'Result.unwrapOr': 'resultUnwrapOr', 'Result.toOption': 'resultToOption', 'Result.collect': 'resultCollect', 'Result.collectErrors': 'resultCollectErrors',
+                'Validation.valid': 'valid', 'Validation.invalid': 'invalid', 'Validation.map': 'validationMap', 'Validation.andThen': 'validationAndThen', 'Validation.collect': 'validationCollect',
+                'Task.sleep': 'taskSleepBuiltin', 'Task.timeout': 'taskTimeoutBuiltin', 'Task.race': 'taskRaceBuiltin', 'Task.firstOk': 'taskFirstOkBuiltin', 'Task.retry': 'taskRetryBuiltin', 'Task.mapParallel': 'taskMapParallelBuiltin', 'Task.supervise': 'taskSuperviseBuiltin',
+                'Stream.fromList': 'streamFromList', 'Stream.map': 'streamMap', 'Stream.filter': 'streamFilter', 'Stream.collect': 'streamCollect', 'Stream.take': 'streamTake',
+                'File.readText': '$fileReadText', 'File.writeText': '$fileWriteText', 'File.readBytes': '$fileReadBytes', 'File.writeBytes': '$fileWriteBytes', 'File.open': '$fileOpen', 'File.read': '$fileRead', 'File.readHandleBytes': '$fileReadHandleBytes', 'File.write': '$fileWrite', 'File.writeHandleBytes': '$fileWriteHandleBytes', 'File.close': '$fileClose',
+                'Path.join': '$pathJoin', 'Path.resolve': '$pathResolve', 'Path.dirname': '$pathDirname', 'Path.basename': '$pathBasename', 'Path.extname': '$pathExtname', 'Path.normalize': '$pathNormalize', 'Path.relative': '$pathRelative', 'Path.isAbsolute': '$pathIsAbsolute',
+                'Process.args': '$processArgs', 'Process.cwd': '$processCwd', 'Process.exitCode': '$processExitCode', 'Process.environment': '$processEnvironment', 'Process.platform': '$processPlatform', 'Process.architecture': '$processArchitecture',
+                'Http.get': '$httpGet', 'Http.request': '$httpRequest', 'Fetch.get': '$fetchGet', 'Fetch.request': '$fetchRequest', 'Timer.sleep': '$timerSleep', 'Timer.now': '$timerNow',
+                'Storage.get': '$storageGet', 'Storage.set': '$storageSet', 'Storage.remove': '$storageRemove', 'Storage.clear': '$storageClear',
+                'Dom.getText': '$domGetText', 'Dom.setText': '$domSetText', 'Dom.setAttribute': '$domSetAttribute', 'Dom.addClass': '$domAddClass',
+                'Crypto.randomUuid': '$cryptoRandomUuid', 'Url.encodeComponent': '$urlEncodeComponent', 'Url.decodeComponent': '$urlDecodeComponent', 'Url.isValid': '$urlIsValid', 'Json.parse': 'parseJson',
+            };
+            if (mapped[key] !== undefined)
+                return mapped[key];
+            const symbol = expression.target.symbolId === undefined ? undefined : this.#semantic.symbols.get(expression.target.symbolId);
+            const type = symbol === undefined ? undefined : this.#semantic.arena.get(symbol.typeId);
+            if (symbol?.kind === 'type' && type?.kind === 'named' && type.declarationKind === 'newtype' && expression.field === 'create')
+                return '(value => value)';
+        }
+        return `${this.expression(expression.target, contextName)}.${safeName(expression.field)}`;
+    }
+    binary(expression, contextName) {
+        const left = this.expression(expression.left, contextName);
+        const right = this.expression(expression.right, contextName);
+        if (['==', '!='].includes(expression.operator))
+            return expression.operator === '==' ? `viruneEquals(${left}, ${right})` : `!viruneEquals(${left}, ${right})`;
+        if (expression.inferredTypeId === this.#semantic.arena.int) {
+            const helpers = { '+': 'intAdd', '-': 'intSubtract', '*': 'intMultiply', '/': 'intDivide', '%': 'intRemainder' };
+            if (helpers[expression.operator] !== undefined)
+                return `${helpers[expression.operator]}(${left}, ${right})`;
+        }
+        return `(${left} ${expression.operator} ${right})`;
+    }
+    match(expression, contextName) {
+        const temp = `$match${this.#temporary++}`;
+        const lines = [`(() => {`, `\tconst ${temp} = ${this.expression(expression.target, contextName)};`];
+        for (const arm of expression.arms) {
+            const pattern = this.pattern(arm.pattern, temp);
+            lines.push(`\tif (${pattern.condition}) {`);
+            for (const binding of pattern.bindings)
+                lines.push(`\t\t${binding}`);
+            if (arm.guard !== undefined)
+                lines.push(`\t\tif (${this.expression(arm.guard, contextName)}) return ${this.expression(arm.expression, contextName)};`);
+            else
+                lines.push(`\t\treturn ${this.expression(arm.expression, contextName)};`);
+            lines.push('\t}');
+        }
+        lines.push(`\treturn panic('Non-exhaustive match reached at runtime');`, '})()');
+        return lines.join('\n');
+    }
+    pattern(pattern, target) {
+        switch (pattern.kind) {
+            case 'WildcardPattern': return { condition: 'true', bindings: [] };
+            case 'BindingPattern': return { condition: 'true', bindings: [`const ${this.nameOf(pattern.symbolId, pattern.name)} = ${target};`] };
+            case 'LiteralPattern': return { condition: `viruneEquals(${target}, ${JSON.stringify(pattern.value)})`, bindings: [] };
+            case 'VariantPattern': {
+                const conditions = [`${target}.$tag === ${JSON.stringify(pattern.name)}`];
+                const bindings = [];
+                pattern.values.forEach((value, index) => { const child = this.pattern(value, `${target}.$values[${index}]`); conditions.push(child.condition); bindings.push(...child.bindings); });
+                return { condition: conditions.join(' && '), bindings };
+            }
+            case 'RecordPattern': {
+                const conditions = [];
+                const bindings = [];
+                for (const field of pattern.fields) {
+                    const child = this.pattern(field.pattern, `${target}.${safeName(field.name)}`);
+                    conditions.push(child.condition);
+                    bindings.push(...child.bindings);
+                }
+                return { condition: conditions.length === 0 ? 'true' : conditions.join(' && '), bindings };
+            }
+            case 'RangePattern': return { condition: `Number.isSafeInteger(${target}) && ${target} >= ${pattern.start} && ${target} <= ${pattern.end}`, bindings: [] };
+            case 'ListPattern': {
+                const conditions = [`Array.isArray(${target})`, `${target}.length ${pattern.rest === undefined ? '===' : '>='} ${pattern.items.length}`];
+                const bindings = [];
+                pattern.items.forEach((item, index) => { const child = this.pattern(item, `${target}[${index}]`); conditions.push(child.condition); bindings.push(...child.bindings); });
+                if (pattern.rest?.kind === 'BindingPattern')
+                    bindings.push(`const ${this.nameOf(pattern.rest.symbolId, pattern.rest.name)} = ${target}.slice(${pattern.items.length});`);
+                return { condition: conditions.join(' && '), bindings };
+            }
+            case 'TuplePattern': {
+                const conditions = [`Array.isArray(${target})`, `${target}.length === ${pattern.items.length}`];
+                const bindings = [];
+                pattern.items.forEach((item, index) => { const child = this.pattern(item, `${target}[${index}]`); conditions.push(child.condition); bindings.push(...child.bindings); });
+                return { condition: conditions.join(' && '), bindings };
+            }
+            case 'OrPattern': {
+                const alternatives = pattern.alternatives.map(item => this.pattern(item, target));
+                return { condition: alternatives.map(item => `(${item.condition})`).join(' || '), bindings: alternatives.flatMap(item => item.bindings) };
+            }
+        }
+    }
+    parallelExpression(expression, contextName) {
+        const helper = expression.tryMode ? 'parallelTry' : 'parallel';
+        const entries = expression.entries.map(entry => `${safeName(entry.name)}: async ($child) => ${this.expression(entry.value, '$child')}`).join(', ');
+        return `${helper}(${contextName}, { ${entries} })`;
+    }
+    acceptsTaskContext(callee) {
+        if (callee.inferredTypeId !== undefined) {
+            const inferred = this.#semantic.arena.get(callee.inferredTypeId);
+            if (inferred.kind === 'function' && inferred.async)
+                return true;
+        }
+        if (callee.kind === 'LambdaExpression')
+            return callee.async;
+        if (callee.kind !== 'IdentifierExpression' || callee.symbolId === undefined)
+            return false;
+        const symbol = this.#semantic.symbols.get(callee.symbolId);
+        if (symbol === undefined || symbol.typeOnly)
+            return false;
+        return symbol.kind === 'function' || symbol.kind === 'import';
+    }
+    typeDescriptorFromTypeId(typeId, seen = new Set()) {
+        if (seen.has(typeId))
+            return `{ kind: 'unknown' }`;
+        seen.add(typeId);
+        const type = this.#semantic.arena.get(typeId);
+        switch (type.kind) {
+            case 'primitive':
+                switch (type.name) {
+                    case 'String': return `{ kind: 'string' }`;
+                    case 'Bool': return `{ kind: 'bool' }`;
+                    case 'Int': return `{ kind: 'int' }`;
+                    case 'Float': return `{ kind: 'float' }`;
+                    case 'BigInt': return `{ kind: 'bigint' }`;
+                    case 'Unit': return `{ kind: 'unit' }`;
+                    default: return `{ kind: 'unknown' }`;
+                }
+            case 'list': return `{ kind: 'list', item: ${this.typeDescriptorFromTypeId(type.element, new Set(seen))} }`;
+            case 'tuple': return `{ kind: 'tuple', items: [${type.items.map(item => this.typeDescriptorFromTypeId(item, new Set(seen))).join(', ')}] }`;
+            case 'map': return `{ kind: 'map', key: ${this.typeDescriptorFromTypeId(type.key, new Set(seen))}, value: ${this.typeDescriptorFromTypeId(type.value, new Set(seen))} }`;
+            case 'set': return `{ kind: 'set', item: ${this.typeDescriptorFromTypeId(type.element, new Set(seen))} }`;
+            case 'option': return `{ kind: 'option', value: ${this.typeDescriptorFromTypeId(type.value, new Set(seen))} }`;
+            case 'result': return `{ kind: 'result', value: ${this.typeDescriptorFromTypeId(type.value, new Set(seen))}, error: ${this.typeDescriptorFromTypeId(type.error, new Set(seen))} }`;
+            case 'named': {
+                if (type.definitionId === 'std:Bytes')
+                    return `{ kind: 'bytes' }`;
+                if ((type.declarationKind === 'newtype' || type.declarationKind === 'alias') && type.underlying !== undefined)
+                    return this.typeDescriptorFromTypeId(type.underlying, new Set(seen));
+                if (type.declarationKind === 'record' && type.fields !== undefined) {
+                    const declaration = this.#moduleDeclarations.find(item => item.kind === 'RecordDeclaration' && item.name === type.name);
+                    const strict = declaration?.attributes.some(attribute => attribute.name === 'json' && attribute.arguments.some(argument => argument.kind === 'IdentifierExpression' && argument.name === 'strict')) === true;
+                    return `{ kind: 'record', name: ${javascriptStringLiteral(type.name)}, typeId: ${javascriptStringLiteral(type.definitionId)}, fields: { ${[...type.fields].map(([name, field]) => `[${javascriptStringLiteral(name)}]: ${this.recordFieldDescriptor(name, this.typeDescriptorFromTypeId(field, new Set(seen)), declaration)}`).join(', ')} }${strict ? ', strict: true' : ''} }`;
+                }
+                if (type.declarationKind === 'enum' && type.variants !== undefined)
+                    return `{ kind: 'enum', name: ${javascriptStringLiteral(type.name)}, typeId: ${javascriptStringLiteral(type.definitionId)}, variants: { ${[...type.variants].map(([name, values]) => `[${javascriptStringLiteral(name)}]: [${values.map(value => this.typeDescriptorFromTypeId(value, new Set(seen))).join(', ')}]`).join(', ')} } }`;
+                return `{ kind: 'unknown' }`;
+            }
+            default: return `{ kind: 'unknown' }`;
+        }
+    }
+    recordFieldDescriptor(name, typeDescriptor, declaration) {
+        const field = declaration?.fields.find(item => item.name === name);
+        const jsonName = field?.attributes.find(attribute => attribute.name === 'jsonName')?.arguments[0];
+        const jsonDefault = field?.attributes.find(attribute => attribute.name === 'jsonDefault')?.arguments[0];
+        const jsOptional = field?.attributes.some(attribute => attribute.name === 'jsOptional') === true;
+        if (jsonName === undefined && jsonDefault === undefined && !jsOptional)
+            return typeDescriptor;
+        const properties = [`type: ${typeDescriptor}`];
+        if (jsonName?.kind === 'LiteralExpression' && jsonName.literalKind === 'String')
+            properties.push(`jsonName: ${javascriptStringLiteral(jsonName.value)}`);
+        if (jsonDefault !== undefined)
+            properties.push(`hasDefault: true`, `defaultValue: ${this.expression(jsonDefault)}`);
+        if (jsOptional)
+            properties.push(`missingAsNone: true`, `omitWhenNone: true`);
+        return `{ ${properties.join(', ')} }`;
+    }
+    typeDescriptor(type) {
+        if (type === undefined)
+            return `{ kind: 'unknown' }`;
+        if (type.resolvedTypeId !== undefined)
+            return this.typeDescriptorFromTypeId(type.resolvedTypeId);
+        const base = (() => {
+            switch (type.name) {
+                case 'String': return `{ kind: 'string' }`;
+                case 'Bool': return `{ kind: 'bool' }`;
+                case 'Int': return `{ kind: 'int' }`;
+                case 'Float': return `{ kind: 'float' }`;
+                case 'BigInt': return `{ kind: 'bigint' }`;
+                case 'Unit': return `{ kind: 'unit' }`;
+                case 'Unknown': return `{ kind: 'unknown' }`;
+                case 'Bytes': return `{ kind: 'bytes' }`;
+                case 'List': return `{ kind: 'list', item: ${this.typeDescriptor(type.arguments[0])} }`;
+                case 'Map': return `{ kind: 'map', key: ${this.typeDescriptor(type.arguments[0])}, value: ${this.typeDescriptor(type.arguments[1])} }`;
+                case 'Set': return `{ kind: 'set', item: ${this.typeDescriptor(type.arguments[0])} }`;
+                case 'Option': return `{ kind: 'option', value: ${this.typeDescriptor(type.arguments[0])} }`;
+                case 'Result': return `{ kind: 'result', value: ${this.typeDescriptor(type.arguments[0])}, error: ${this.typeDescriptor(type.arguments[1])} }`;
+            }
+            const declaration = this.#moduleDeclarations.find(item => 'name' in item && item.name === type.name);
+            if (declaration?.kind === 'RecordDeclaration')
+                return `{ kind: 'record', name: ${javascriptStringLiteral(type.name)}, typeId: ${javascriptStringLiteral(this.declarationTypeId(declaration.symbolId, declaration.definitionId ?? `${this.#source.id}#${declaration.name}`))}, fields: { ${declaration.fields.map(field => `[${javascriptStringLiteral(field.name)}]: ${this.recordFieldDescriptor(field.name, this.typeDescriptor(field.type), declaration)}`).join(', ')} } }`;
+            if (declaration?.kind === 'EnumDeclaration')
+                return `{ kind: 'enum', name: ${javascriptStringLiteral(type.name)}, typeId: ${javascriptStringLiteral(this.declarationTypeId(declaration.symbolId, declaration.definitionId ?? `${this.#source.id}#${declaration.name}`))}, variants: { ${declaration.variants.map(variant => `[${javascriptStringLiteral(variant.name)}]: [${variant.values.map(value => this.typeDescriptor(value)).join(', ')}]`).join(', ')} } }`;
+            if (declaration?.kind === 'NewtypeDeclaration')
+                return this.typeDescriptor(declaration.underlying);
+            if (declaration?.kind === 'TypeAliasDeclaration')
+                return this.typeDescriptor(declaration.target);
+            return `{ kind: 'unknown' }`;
+        })();
+        return type.optional ? `{ kind: 'option', value: ${base} }` : base;
+    }
+    safeFfiBoundary(typeDescriptor) {
+        return `{ version: 'virune-safe-ffi/v1', type: ${typeDescriptor} }`;
+    }
+    declarationTypeId(symbolId, fallback) {
+        if (symbolId === undefined)
+            return fallback;
+        const symbol = this.#semantic.symbols.get(symbolId);
+        const type = symbol === undefined ? undefined : this.#semantic.arena.get(symbol.typeId);
+        return type?.kind === 'named' ? type.definitionId : fallback;
+    }
+    nameOf(symbolId, fallback) { return symbolId === undefined ? safeName(fallback) : this.#symbolNames.get(symbolId) ?? safeName(fallback); }
+    moduleExported(declaration) { return declaration.public || declaration.internal === true; }
+    exportPrefix(attributes) { return attributes.some(item => item.name === 'jsExport') ? 'export ' : ''; }
+}
+export function emitJavaScript(hir, source, outputFile, options = {}) {
+    return new JavaScriptEmitter(hir, source, outputFile, options).emit(hir.module);
+}
+//# sourceMappingURL=emitter.js.map