@greenpandastudios/aug-cli 0.19.0

package/src/codegen.js

@@ -0,0 +1,1159 @@
+import { fieldsOf, initializationOf, isStatement, typeName } from "./ast.js";
+import { builtinProperties, collectionOperations, errorNames } from "./builtins.js";
+import { interceptorChain, InterceptorInvocation } from "./interceptors.js";
+import { NativeSchemas, schemaType } from "./schemas.js";
+import { resolve } from 'node:path';
+import { generateOpenApi, apiExplorer, apiExplorerScript } from "./openapi.js";
+import { actionSchema, actionTransport } from "./actions.js";
+import { httpPolicyNativeName } from "./http-policies.js";
+function cString(value) {
+    return '"' + [...value].map(char => char === '"' ? '\\"' : char === '\\' ? '\\\\' :
+        char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127 ? '\\' + char.charCodeAt(0).toString(8).padStart(3, '0') : char).join('') + '"';
+}
+export function generateC(checked, options = {}) {
+    return new CGenerator(checked, options).generate();
+}
+class CGenerator {
+    checked;
+    names = new Map();
+    bindings = new Map();
+    classByName = new Map();
+    functions = [];
+    constructors = [];
+    tables = [];
+    prototypes = [];
+    externs = [];
+    taskThunk(emitter, count) {
+        const name = `aug_task_entry_${this.sequence++}`;
+        this.prototypes.push(`static AugValue ${name}(AugValue self, AugValue *args, int count);`);
+        this.functions.push(emitter.finish(name, true, count));
+        return name;
+    }
+    markupCall(expr) { return this.checked.markupCalls.get(expr); }
+    actionPlan(expr) { return this.checked.actions.get(expr); }
+    actionSchema(type) { return actionSchema(this.checked.project, type); }
+    sequence = 0;
+    options;
+    coverage = new Map();
+    activeFiles = new Set();
+    schemas;
+    constructor(checked, options) {
+        this.checked = checked;
+        this.options = options;
+        this.schemas = new NativeSchemas(checked.project, def => this.constructorName(def));
+        const activate = (file) => {
+            if (this.activeFiles.has(file))
+                return;
+            this.activeFiles.add(file);
+            for (const item of checked.project.files.get(file)?.items ?? [])
+                if (item.kind === 'import')
+                    for (const def of checked.project.imports.get(item) ?? [])
+                        activate(def.file);
+        };
+        for (const file of checked.project.files.values())
+            if (!file.builtin)
+                activate(file.path);
+        for (const def of checked.project.definitions.values()) {
+            this.names.set(def.id, `aug_${this.sequence++}_${def.name}`);
+            if (def.node.kind === 'class')
+                this.classByName.set(def.name, def);
+        }
+        checked.bindings.forEach((binding, index) => this.bindings.set(binding.key, index));
+    }
+    name(def) { return this.names.get(def.id); }
+    constructorName(def) { return `aug_construct_${this.name(def)}`; }
+    initializerName(def) { return `aug_initialize_${this.name(def)}`; }
+    methodName(def, method) { return `${this.name(def)}_${method}`; }
+    bodyName(node, name) {
+        return interceptorChain(name, this.checked.interceptorPlans.get(node) ?? []).body;
+    }
+    declareCallable(node, name, method) {
+        const signature = `${method ? 'AugValue self, ' : ''}AugValue *args, int count`;
+        this.prototypes.push(`static AugValue ${name}(${signature});`);
+        const chain = interceptorChain(name, this.checked.interceptorPlans.get(node) ?? []);
+        if (chain.entries.length) {
+            this.prototypes.push(`static AugValue ${chain.body}(${signature});`);
+            for (const entry of chain.entries.slice(1))
+                this.prototypes.push(`static AugValue ${entry.name}(${signature});`);
+        }
+    }
+    generate() {
+        for (const def of this.checked.project.definitions.values()) {
+            if (!this.activeFiles.has(def.file))
+                continue;
+            if (def.node.kind === 'class' || def.node.kind === 'interceptor') {
+                for (const method of def.node.methods) {
+                    if (def.node.kind === 'interceptor' && method.name === 'around')
+                        continue;
+                    this.declareCallable(method, this.methodName(def, method.name), true);
+                }
+                for (const entry of this.checked.defaults.get(def.id)?.values() ?? []) {
+                    const method = entry.method;
+                    if (!def.node.methods.some(item => item.name === method.name))
+                        this.declareCallable(method, this.methodName(def, method.name), true);
+                }
+                if (def.node.kind === 'class')
+                    this.declareCallable(def.node, this.constructorName(def), false);
+                else
+                    this.prototypes.push(`static AugValue ${this.constructorName(def)}(AugValue *args, int count);`);
+                if (def.node.kind === 'class' && initializationOf(def.node).length)
+                    this.prototypes.push(`static AugValue ${this.initializerName(def)}(AugValue self, AugValue *args, int count);`);
+            }
+            else if (def.node.kind === 'function') {
+                if (def.node.endpoint)
+                    this.prototypes.push(`static AugValue ${this.name(def)}_http(AugValue *incoming, int count);`);
+                if (def.node.externC)
+                    this.externs.push(this.externPrototype(def.node));
+                if (!def.node.externC || this.checked.interceptorPlans.get(def.node)?.length)
+                    this.declareCallable(def.node, this.name(def), false);
+            }
+        }
+        for (const def of this.checked.project.definitions.values()) {
+            if (!this.activeFiles.has(def.file))
+                continue;
+            if (def.node.kind === 'class' || def.node.kind === 'interceptor')
+                this.emitClass(def);
+            else if (def.node.kind === 'function') {
+                if (def.node.body)
+                    this.functions.push(this.emitFunction(def.node, def.file, def));
+                else if (def.node.externC && this.checked.interceptorPlans.get(def.node)?.length) {
+                    const emitter = new BodyEmitter(this, def.file, def);
+                    def.node.params.forEach((param, index) => emitter.addParameter(param.name, index));
+                    emitter.emitNativeReturn(def);
+                    this.functions.push(emitter.finish(this.bodyName(def.node, this.name(def)), false, def.node.params.length));
+                }
+                this.emitInterceptors(def.node, this.name(def), def.node.params, false);
+                if (def.node.endpoint)
+                    this.emitEndpoint(def);
+            }
+        }
+        const mainBody = this.emitMainBody();
+        const bindingCount = this.checked.bindings.length;
+        const bindingArray = `static AugValue aug_bindings[${Math.max(1, bindingCount)}];`;
+        const initializeBindings = this.checked.bindings.filter(binding => binding.lifetime === 'shared').map(binding => `  aug_resolve_${this.bindingIndex(binding.key)}(); if (aug_has_error) { aug_report_error(); aug_shutdown(); return 1; }`).join('\n');
+        return [
+            '#include "aug_runtime.h"',
+            '#include <stdio.h>',
+            '#include <stdbool.h>',
+            '#include <string.h>',
+            '#include <stdlib.h>',
+            '',
+            ...new Set(this.externs),
+            bindingArray,
+            `static const unsigned char aug_scoped[${Math.max(1, bindingCount)}] = { ${this.checked.bindings.map(binding => binding.lifetime === 'scoped' ? '1' : '0').join(', ') || '0'} };`,
+            ...this.checked.bindings.map(binding => `static AugValue aug_resolve_${this.bindingIndex(binding.key)}(void);`),
+            ...this.prototypes,
+            this.schemas.declarations(),
+            '',
+            ...this.tables,
+            ...this.constructors,
+            ...this.functions,
+            ...this.checked.bindings.map(binding => this.emitBinding(binding)),
+            mainBody,
+            `int main(int argc, char **argv) {`,
+            `  aug_register_globals(aug_bindings, ${bindingCount});`,
+            `  aug_set_cli_args(argc, argv);`,
+            ...([...this.activeFiles].some(file => this.checked.project.files.get(file)?.items.some(item => item.kind === 'function' && !!item.endpoint) ||
+                [...this.checked.project.definitions.values()].some(def => def.file === file && def.id.startsWith('august/web/'))) ? [this.httpConfiguration()] : []),
+            ...[...this.coverage.values()].map(point => `  aug_coverage_register(${cString(point.file)}, ${point.line});`),
+            initializeBindings,
+            `  AugValue result = aug_main_body(NULL, 0);`,
+            `  (void)result;`,
+            `  if (aug_has_error) { aug_report_error(); aug_shutdown(); return 1; }`,
+            `  int status = aug_test_failed ? 1 : 0;`,
+            ...(this.checked.project.testMode ? [
+                `  if (aug_test_assertions == 0) { fprintf(stderr, "Test executed no assertions\\n"); status = 1; }`,
+            ] : []),
+            `  aug_shutdown();`,
+            `  return status;`,
+            `}`,
+            '',
+        ].join('\n');
+    }
+    externPrototype(method) {
+        if (method.valueAbi)
+            return `extern AugValue ${method.name}(${method.params.length ? method.params.map(() => 'AugValue').join(', ') : 'void'});`;
+        const toC = (name) => name === 'string' ? 'const char *' :
+            name === 'int' ? 'int64_t' : name === 'c_int' ? 'int' : name === 'float' ? 'double' : name === 'bool' ? 'bool' : 'void';
+        return `#line ${method.span.line} ${cString(method.span.file)}\nextern ${toC(method.returns.name)} ${method.name}(${method.params.length ?
+            method.params.map(param => toC(param.type.name)).join(', ') : 'void'});`;
+    }
+    emitClass(def) {
+        const cls = def.node;
+        const methods = cls.methods.filter(method => cls.kind !== 'interceptor' || method.name !== 'around');
+        for (const entry of this.checked.defaults.get(def.id)?.values() ?? []) {
+            const method = entry.method;
+            if (!methods.some(own => own.name === method.name))
+                methods.push(method);
+        }
+        const tableName = `${this.name(def)}_methods`;
+        const ownTableName = `${this.name(def)}_owned_fields`;
+        this.tables.push(`static const AugMethodEntry ${tableName}[] = {`);
+        for (const method of methods)
+            this.tables.push(`  {${cString(method.name)}, ${this.methodName(def, method.name)}},`);
+        this.tables.push('};');
+        this.tables.push(`static const char *const ${this.name(def)}_field_names[] = {${fieldsOf(cls).map(field => cString(field.name)).join(', ') || 'NULL'}};`);
+        this.tables.push(`static const unsigned char ${ownTableName}[] = { ${fieldsOf(cls).map(field => field.ownership === 'own' ? '1' : '0').join(', ') || '0'} };`);
+        this.constructors.push([
+            `static AugValue ${cls.kind === 'class' ? this.bodyName(cls, this.constructorName(def)) : this.constructorName(def)}(AugValue *args, int count) {`,
+            `  if (count != ${cls.fields.length}) { fprintf(stderr, "${cls.name} constructor argument mismatch\\n"); return aug_scalar_null(); }`,
+            `  AugValue roots[${cls.fields.length + 1}] = {0};`,
+            `  AugFrame frame; aug_frame_enter(&frame, roots, ${cls.fields.length + 1});`,
+            ...cls.fields.map((_, index) => `  roots[${index}] = args[${index}];`),
+            `  roots[${cls.fields.length}] = aug_new_object(${cString(cls.kind === 'class' && cls.record ? def.id : cls.name)}, ${fieldsOf(cls).length}, ${ownTableName}, ${tableName}, ${methods.length});`,
+            ...cls.fields.map((_, index) => `  aug_set_field(roots[${cls.fields.length}], ${index}, roots[${index}]);`),
+            ...(cls.kind === 'class' && cls.record ? [`  roots[${cls.fields.length}].as.object->kind = AUG_RECORD_KIND;`] : []),
+            `  AugValue value = roots[${cls.fields.length}];`,
+            `  value.as.object->field_names = ${this.name(def)}_field_names;`,
+            ...(cls.kind === 'class' && initializationOf(cls).length ? [`  ${this.initializerName(def)}(value, NULL, 0);`] : []),
+            ...(cls.kind === 'class' && cls.record ? ['  aug_freeze(value);'] : []),
+            `  aug_frame_leave(&frame);`,
+            `  return value;`,
+            `}`,
+        ].join('\n'));
+        if (cls.kind === 'class' && initializationOf(cls).length) {
+            const initializer = new BodyEmitter(this, def.file, def, cls);
+            initializer.addParameter('self', 0);
+            for (const statement of initializationOf(cls))
+                initializer.emitStatement(statement);
+            this.functions.push(initializer.finish(this.initializerName(def), true, 0));
+        }
+        for (const method of methods) {
+            this.functions.push(this.emitFunction(method, method.span.file, def, cls));
+            this.emitInterceptors(method, this.methodName(def, method.name), method.params, true);
+        }
+        if (cls.kind === 'class')
+            this.emitInterceptors(cls, this.constructorName(def), cls.fields, false);
+    }
+    emitInterceptors(node, name, params, method) {
+        for (const { layer, name: entry, next } of interceptorChain(name, this.checked.interceptorPlans.get(node) ?? []).entries) {
+            const owner = layer.definition.node;
+            const emitter = new BodyEmitter(this, layer.definition.file, layer.definition, owner);
+            emitter.initializeInterceptor(layer, params, next, method);
+            for (const stmt of layer.around.body ?? [])
+                emitter.emitStatement(stmt);
+            this.functions.push(emitter.finish(entry, method, params.length));
+        }
+    }
+    emitBinding(binding) {
+        const index = this.bindings.get(binding.key);
+        const count = binding.constructorKeys.length;
+        return [
+            `static AugValue aug_resolve_${index}(void) {`,
+            ...(binding.lifetime !== 'fresh' ? [`  if (aug_binding_get(${index}).tag != AUG_NULL) return aug_binding_get(${index});`] : []),
+            `  AugValue roots[${count + 1}] = {0}; AugFrame frame; aug_frame_enter(&frame, roots, ${count + 1});`,
+            ...binding.constructorKeys.flatMap((key, input) => [`  roots[${input}] = aug_resolve_${this.bindings.get(key)}();`,
+                `  if (aug_has_error) goto done;`]),
+            `  roots[${count}] = ${this.constructorName(binding.target)}(roots, ${count});`,
+            ...(binding.lifetime !== 'fresh' ? [`  if (!aug_has_error) aug_binding_set(${index}, roots[${count}]);`] : []),
+            `done:; AugValue result = roots[${count}]; aug_frame_leave(&frame); return result;`,
+            `}`,
+        ].join('\n');
+    }
+    emitEndpoint(def) {
+        const fn = def.node, endpoint = fn.endpoint, count = fn.params.length;
+        const policies = this.checked.httpPolicies.get(fn) ?? [];
+        const policyTable = `${this.name(def)}_policies`;
+        this.tables.push(`static const AugHttpPolicy ${policyTable}[] = {`);
+        for (const policy of policies) {
+            const option = policy.options;
+            this.tables.push(`  {${httpPolicyNativeName(policy.name)}, ${cString(String(option.permission ?? ''))}, ${Number(option.requests ?? option.milliseconds ?? 0)}, ${Number(option.seconds ?? 0)}, ${option.credentials ? 'true' : 'false'}, ${cString((option.origins ?? []).join('\n'))}, ${cString((option.headers ?? []).map(header => header.toLowerCase()).join(', '))}},`);
+        }
+        if (!policies.length)
+            this.tables.push('  {0},');
+        this.tables.push('};');
+        const statements = fn.params.map((param, index) => {
+            if (param.injected) {
+                const type = schemaType(this.checked.project, param.type, def.file);
+                const key = type.name + (type.args.length ? `<${type.args.map(arg => arg.name).join(',')}>` : '');
+                return `  roots[${index}] = aug_resolve_${this.bindingIndex(key)}(); if (aug_has_error) goto failed;`;
+            }
+            const schema = param.source?.kind === 'request' ? 'NULL' : '&' + this.schema(schemaType(this.checked.project, param.type, def.file));
+            return `  roots[${index}] = aug_http_bind(roots[${count + 1}], ${cString(param.source.kind)}, ${cString(param.source.name ?? param.name)}, ${schema}); if (aug_has_error) goto failed;`;
+        });
+        this.functions.push([
+            `static AugValue ${this.name(def)}_http(AugValue *incoming, int count) {`,
+            `  (void)count; AugValue roots[${count + 2}] = {0}; AugFrame frame; aug_frame_enter(&frame, roots, ${count + 2});`,
+            `  roots[${count + 1}] = incoming[0]; size_t scope_depth = aug_scope_depth(); aug_scope_enter(aug_scoped);`,
+            ...statements.filter((_, index) => fn.params[index].injected),
+            ...policies.map((policy, index) => `  aug_http_policy(&${policyTable}[${index}], roots[${count + 1}], ${policy.dependencies[0] === undefined ? 'aug_scalar_null()' : `roots[${policy.dependencies[0]}]`}, ${policy.dependencies[1] === undefined ? 'aug_scalar_null()' : `roots[${policy.dependencies[1]}]`}); if (aug_has_error) goto failed;`),
+            ...statements.filter((_, index) => !fn.params[index].injected),
+            `  roots[${count}] = ${this.name(def)}(roots, ${count}); if (aug_has_error) goto failed;`,
+            `  roots[${count}] = aug_http_response(roots[${count}], ${endpoint.status}); goto finished;`,
+            'failed:',
+            `  { int status = aug_http_error_status();`,
+            ...endpoint.errors.map(error => `    if (aug_error_is(${cString(error.type.name)})) status = ${error.status};`),
+            '    if (status == 500) aug_report_error(); aug_take_error();',
+            `    roots[${count}] = aug_http_problem(status); }`,
+            'finished:',
+            `  roots[${count}] = aug_http_finish(roots[${count}]);`,
+            '  aug_scope_restore(scope_depth);',
+            `  AugValue result = roots[${count}]; aug_frame_leave(&frame); return result;`,
+            '}',
+        ].join('\n'));
+    }
+    serveRoutes(file, names) {
+        const name = `aug_routes_${this.tables.length}`;
+        const config = this.checked.project.config.openapi;
+        if (config.enabled) {
+            const assets = [JSON.stringify(generateOpenApi(this.checked).document), apiExplorer(config.path, config.docs + '/client.js'), apiExplorerScript];
+            ['application/json', 'text/html; charset=utf-8', 'application/javascript; charset=utf-8'].forEach((type, index) => {
+                const fn = `${name}_docs_${index}`;
+                this.tables.push(`static AugValue ${fn}(AugValue *args, int count) { (void)args; (void)count; AugValue roots[3] = {0}; AugFrame frame; aug_frame_enter(&frame, roots, 3);` +
+                    ` roots[0] = aug_bytes(${cString(assets[index])}, ${Buffer.byteLength(assets[index])}, AUG_BYTES_KIND); roots[1] = aug_headers_new(); roots[2] = aug_string(${cString(type)});` +
+                    ` roots[1] = aug_headers_with(roots[1], aug_string("content-type"), roots[2]); roots[0] = aug_http_response_full(roots[0], aug_int(200), roots[1]); AugValue result = roots[0]; aug_frame_leave(&frame); return result; }`);
+            });
+        }
+        if (this.checked.actions.size)
+            this.tables.push(`static AugValue ${name}_actions(AugValue *args, int count) { (void)args; (void)count; AugValue roots[2] = {0}; AugFrame frame; aug_frame_enter(&frame, roots, 2); roots[0] = aug_bytes(${cString(actionTransport)}, ${Buffer.byteLength(actionTransport)}, AUG_BYTES_KIND); roots[1] = aug_headers_new(); roots[1] = aug_headers_with(roots[1], aug_string("content-type"), aug_string("application/javascript; charset=utf-8")); roots[0] = aug_http_response_full(roots[0], aug_int(200), roots[1]); AugValue result = roots[0]; aug_frame_leave(&frame); return result; }`);
+        this.tables.push(`static const AugRoute ${name}[] = {`);
+        for (const symbol of names) {
+            const def = this.definition(file, symbol);
+            const endpoint = def.node.endpoint;
+            const item = def.node.returns.name;
+            this.tables.push(`  {${cString(endpoint.method)}, ${cString(endpoint.path)}, ${this.name(def)}_http, ${endpoint.streams ? item === 'ServerEvent' ? 1 : item === 'Bytes' ? 2 : 3 : 0}, ${endpoint.status}, ${this.name(def)}_policies, ${(this.checked.httpPolicies.get(def.node) ?? []).length}},`);
+        }
+        if (config.enabled)
+            [config.path, config.docs, config.docs + '/client.js'].forEach((path, index) => this.tables.push(`  {"GET", ${cString(path)}, ${name}_docs_${index}},`));
+        if (this.checked.actions.size)
+            this.tables.push(`  {"GET", "/__aug/actions.js", ${name}_actions},`);
+        this.tables.push('};');
+        return name;
+    }
+    serveRouteCount(count) { return count + (this.checked.project.config.openapi.enabled ? 3 : 0) + (this.checked.actions.size ? 1 : 0); }
+    testEndpoint() { return this.checked.project.testEndpoint; }
+    httpConfiguration() {
+        const config = this.checked.project.config.web, root = this.checked.project.root;
+        const path = (value) => cString(value ? resolve(root, value) : '');
+        return `  aug_http_configure(${cString(config.host)}, ${path(config.tls.certificate)}, ${path(config.tls.private_key)}, ${path(config.tls.ca)}, ${config.body_limit}, ${config.response_limit}, ${config.http3 ? 'true' : 'false'});`;
+    }
+    emitMainBody() {
+        const emitter = new BodyEmitter(this, this.checked.project.main?.path ?? '', undefined, undefined);
+        const items = this.checked.project.main?.items ?? [];
+        for (let index = 0; index <= items.length; index++) {
+            if (this.checked.project.testBodyStart === index)
+                emitter.beginTestCase();
+            const item = items[index];
+            if (item && isStatement(item))
+                emitter.emitStatement(item);
+        }
+        return emitter.finish('aug_main_body', false, 0);
+    }
+    emitFunction(method, file, def, owner) {
+        const emitter = new BodyEmitter(this, file, def, owner);
+        if (owner)
+            emitter.addParameter('self', 0);
+        method.params.forEach((param, index) => emitter.addParameter(param.name, index, param.ownership === 'own'));
+        for (const stmt of method.body ?? [])
+            emitter.emitStatement(stmt);
+        return emitter.finish(this.bodyName(method, owner ? this.methodName(def, method.name) : this.name(def)), !!owner, method.params.length);
+    }
+    definition(file, name) {
+        return this.checked.project.scopes.get(file)?.get(name);
+    }
+    bindingIndex(name) { return this.bindings.get(name) ?? -1; }
+    coveragePoint(stmt) {
+        if (!this.options.coverage || this.checked.project.files.get(stmt.span.file)?.builtin)
+            return false;
+        this.coverage.set(`${stmt.span.file}:${stmt.span.line}`, { file: stmt.span.file, line: stmt.span.line });
+        return true;
+    }
+    expressionType(expr) { return this.checked.expressionTypes.get(expr); }
+    schema(type) { return this.schemas.request(type); }
+    expressionSource(expr) {
+        return this.checked.project.files.get(expr.span.file)?.source.slice(expr.span.start, expr.span.end) ?? 'condition';
+    }
+    callPlan(expr) { return this.checked.callPlans.get(expr); }
+    cName(def) { return this.name(def); }
+    cConstructor(def) { return this.constructorName(def); }
+    cMethod(def, method) { return this.methodName(def, method); }
+    hasInterceptors(node) { return !!this.checked.interceptorPlans.get(node)?.length; }
+}
+class BodyEmitter {
+    generator;
+    file;
+    def;
+    lines = [];
+    locals = new Map();
+    owned = new Set();
+    classFields = new Map();
+    scalarSlots = new Set();
+    slots = 1;
+    labelCounter = 0;
+    errorTarget = 'aug_cleanup';
+    returnTarget = 'aug_cleanup';
+    continuation;
+    constructor(generator, file, def, owner) {
+        this.generator = generator;
+        this.file = file;
+        this.def = def;
+        if (owner)
+            fieldsOf(owner).forEach((field, index) => this.classFields.set(field.name, index));
+    }
+    addParameter(name, index, owned = false) {
+        const slot = this.newSlot();
+        this.locals.set(name, slot);
+        this.lines.push(`roots[${slot}] = ${name === 'self' ? 'self' : `args[${index}]`};`);
+        if (owned)
+            this.owned.add(slot);
+    }
+    initializeInterceptor(layer, params, name, method) {
+        const receiver = method ? this.newSlot() : undefined;
+        if (receiver !== undefined)
+            this.line(`${this.slot(receiver)} = self;`);
+        const original = params.map((param, index) => {
+            const slot = this.newSlot();
+            this.line(`${this.slot(slot)} = args[${index}];`);
+            if (param.ownership === 'own')
+                this.owned.add(slot);
+            return slot;
+        });
+        this.continuation = new InterceptorInvocation(layer, params, original, name, receiver);
+        const array = this.label('interceptor_dependencies');
+        const dependencies = this.continuation.dependencies();
+        this.line(`AugValue ${array}[] = { ${dependencies.map(slot => slot === undefined ? 'aug_scalar_null()' : this.slot(slot)).join(', ') || 'aug_scalar_null()'} };`);
+        const self = this.newSlot();
+        this.locals.set('self', self);
+        this.line(`${this.slot(self)} = ${this.generator.cConstructor(layer.definition)}(${array}, ${dependencies.length});`);
+        this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+        for (const input of this.continuation.inputs()) {
+            if (input.reuseOwnedSlot) {
+                this.locals.set(input.name, input.slot);
+                continue;
+            }
+            const slot = this.newSlot();
+            this.locals.set(input.name, slot);
+            this.line(`${this.slot(slot)} = ${input.slot === undefined ? 'aug_scalar_null()' : this.slot(input.slot)};`);
+        }
+    }
+    emitNativeReturn(def) {
+        const fn = def.node;
+        this.emitExternCall(def, fn.params.map(param => this.locals.get(param.name)), 0);
+        this.line('goto aug_cleanup;');
+    }
+    emitNext(expr) {
+        const next = this.continuation;
+        const values = expr.args.map(arg => this.emitExpr(arg));
+        const plan = this.generator.callPlan(expr);
+        const { args, transfers } = next.forward(plan.sourceIndices, values);
+        const array = this.label('next_args');
+        this.line(`AugValue ${array}[] = { ${args.map(slot => this.slot(slot)).join(', ') || 'aug_scalar_null()'} };`);
+        for (const { original, replacement } of transfers) {
+            if (replacement !== original)
+                this.line(`if (${this.slot(original)}.tag != AUG_NULL) aug_drop(${this.slot(original)});`);
+            this.line(`${this.slot(original)} = aug_scalar_null();`);
+            if (this.owned.has(replacement) && replacement !== original)
+                this.line(`${this.slot(replacement)} = aug_scalar_null();`);
+        }
+        const slot = this.newSlot();
+        this.line(`${this.slot(slot)} = ${next.target}(${next.receiver === undefined ? '' :
+            `${this.slot(next.receiver)}, `}${array}, ${args.length});`);
+        this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+        return slot;
+    }
+    newSlot() { return this.slots++; }
+    slot(index) { return `roots[${index}]`; }
+    line(text) { this.lines.push(text); }
+    label(prefix) { return `${prefix}_${this.labelCounter++}`; }
+    memberIndex(expr, name) {
+        const type = this.generator.expressionType(expr);
+        if (type?.kind === 'builtin')
+            return builtinProperties[type.name]?.findIndex(field => field.name === name) ?? -1;
+        const node = type?.def?.node;
+        return node?.kind === 'class' || node?.kind === 'interceptor' ? fieldsOf(node).findIndex(field => field.name === name) : -1;
+    }
+    isScalar(type) {
+        return !!type && type.kind === 'builtin' && ['int', 'c_int', 'float', 'bool'].includes(type.name);
+    }
+    emitExpr(expr) {
+        const firstNewSlot = this.slots;
+        const slot = this.emitValueExpr(expr);
+        // Scalar temporaries never contain a GC pointer. Keeping them outside the
+        // escaped root array lets the C optimizer keep arithmetic in registers.
+        if (slot >= firstNewSlot && this.isScalar(this.generator.expressionType(expr)))
+            this.scalarSlots.add(slot);
+        return slot;
+    }
+    emitValueExpr(expr) {
+        if (expr.kind === 'handle' && expr.call.kind === 'call') {
+            const plan = this.generator.actionPlan(expr), endpoint = plan.endpoint.node.endpoint;
+            const metadata = { method: endpoint.method, path: endpoint.path, parameters: plan.parameters.map(({ param, type, form }) => ({ name: param.source?.name ?? param.name, source: param.source?.kind, form, schema: this.generator.actionSchema(type) })) };
+            const args = plan.parameters.map(parameter => parameter.form || parameter.source === undefined ? undefined : this.emitExpr(expr.call.args[parameter.source]));
+            const array = this.label('action_values'), slot = this.newSlot();
+            this.line(`AugValue ${array}[] = {${args.map(arg => arg === undefined ? 'aug_null()' : this.slot(arg)).join(', ') || 'aug_scalar_null()'}};`);
+            this.line(`${this.slot(slot)} = aug_http_action(${cString(JSON.stringify(metadata))}, ${array}, ${args.length});`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.kind === 'markupText') {
+            const slot = this.newSlot();
+            this.line(`${this.slot(slot)} = aug_string(${cString(expr.text)});`);
+            return slot;
+        }
+        if (expr.kind === 'markup') {
+            const component = this.generator.markupCall(expr);
+            if (component)
+                return this.emitExpr(component);
+            const names = expr.attributes.map(attribute => this.emitExpr({ kind: 'literal', value: attribute.name, span: attribute.span }));
+            const attrs = expr.attributes.map(attribute => this.emitExpr(attribute.value)), children = expr.children.map(child => this.emitExpr(child));
+            const array = this.label('html_attributes'), body = this.label('html_children'), slot = this.newSlot();
+            this.line(`AugValue ${array}[] = {${expr.attributes.flatMap((_, index) => [this.slot(names[index]), this.slot(attrs[index])]).join(', ') || 'aug_scalar_null()'}};`);
+            this.line(`AugValue ${body}[] = {${children.map(child => this.slot(child)).join(', ') || 'aug_scalar_null()'}};`);
+            this.line(`${this.slot(slot)} = aug_html_element(${cString(expr.tag)}, ${array}, ${attrs.length}, ${body}, ${children.length});`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.kind === 'start' && expr.call.kind === 'call') {
+            const call = expr.call;
+            const { receiver, args } = this.emitArguments(call);
+            const thunk = new BodyEmitter(this.generator, this.file, this.def);
+            thunk.addParameter('self', 0);
+            args.forEach((_, index) => thunk.addParameter(`argument_${index}`, index));
+            const result = thunk.emitInvoke(call, receiver === undefined ? undefined : thunk.locals.get('self'), args.map((_, index) => thunk.locals.get(`argument_${index}`)));
+            thunk.line(`${thunk.slot(0)} = ${thunk.slot(result)};`);
+            const name = this.generator.taskThunk(thunk, args.length), array = this.label('task_args'), slot = this.newSlot();
+            this.line(`AugValue ${array}[] = {${args.map(arg => this.slot(arg)).join(', ') || 'aug_scalar_null()'}};`);
+            this.line(`${this.slot(slot)} = aug_task_start(${name}, ${receiver === undefined ? 'aug_scalar_null()' : this.slot(receiver)}, ${array}, ${args.length});`);
+            this.clearMovedArgs(call, (this.generator.callPlan(call)?.ownerships ?? []).map(ownership => ({ ownership: ownership ?? 'managed' })));
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.kind === 'wait') {
+            const values = expr.tasks.map(task => this.emitExpr(task)), slot = this.newSlot(), array = this.label('wait_tasks');
+            this.line(`AugValue ${array}[] = {${values.map(value => this.slot(value)).join(', ')}};`);
+            this.line(`${this.slot(slot)} = aug_task_wait(${array}, ${values.length});`);
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.kind === 'name') {
+            const local = this.locals.get(expr.name);
+            if (local !== undefined)
+                return local;
+            const field = this.classFields.get(expr.name);
+            if (field !== undefined) {
+                const slot = this.newSlot();
+                this.line(`${this.slot(slot)} = aug_field(${this.slot(this.locals.get('self'))}, ${field});`);
+                return slot;
+            }
+            const slot = this.newSlot();
+            this.line(`${this.slot(slot)} = aug_scalar_null();`);
+            return slot;
+        }
+        if (expr.kind === 'literal') {
+            const slot = this.newSlot();
+            const value = expr.value === null ? 'aug_scalar_null()' : typeof expr.value === 'string' ?
+                `aug_string(${cString(expr.value)})` : typeof expr.value === 'boolean' ?
+                `aug_scalar_bool(${expr.value})` : expr.numericType !== 'float' && Number.isInteger(expr.value) ?
+                `aug_scalar_int(${expr.numericText === '-9223372036854775808' ? 'INT64_MIN' : `INT64_C(${expr.numericText ?? expr.value})`})` : `aug_scalar_float(${expr.value})`;
+            this.line(`${this.slot(slot)} = ${value};`);
+            return slot;
+        }
+        if (expr.kind === 'collection') {
+            const args = expr.items.map(item => this.emitExpr(item));
+            const slot = this.newSlot();
+            const name = this.generator.expressionType(expr)?.name ?? expr.collection;
+            if (name === 'Map') {
+                this.line(`${this.slot(slot)} = aug_map_new();`);
+                for (let index = 0; index < args.length; index += 2)
+                    this.line(`aug_map_set(${this.slot(slot)}, ${this.slot(args[index])}, ${this.slot(args[index + 1])});`);
+            }
+            else {
+                const array = this.label('items');
+                this.line(`AugValue ${array}[] = { ${args.map(index => this.slot(index)).join(', ') || 'aug_scalar_null()'} };`);
+                this.line(`${this.slot(slot)} = aug_${name.toLowerCase()}_new(${array}, ${args.length});`);
+            }
+            return slot;
+        }
+        if (expr.kind === 'resolve') {
+            const slot = this.newSlot();
+            const key = expr.name + (expr.typeArgs.length ? `<${expr.typeArgs.map(typeName).join(',')}>` : '');
+            this.line(`${this.slot(slot)} = aug_resolve_${this.generator.bindingIndex(key)}();`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.kind === 'member') {
+            const object = this.emitExpr(expr.object);
+            const slot = this.newSlot();
+            this.line(`${this.slot(slot)} = aug_field(${this.slot(object)}, ${this.memberIndex(expr.object, expr.name)});`);
+            return slot;
+        }
+        if (expr.kind === 'unary') {
+            const value = this.emitExpr(expr.value);
+            const slot = this.newSlot();
+            const type = this.generator.expressionType(expr.value);
+            const scalar = type && this.isScalar(type) && !type.nullable && !type.optional;
+            const operand = this.slot(value);
+            const fast = scalar && expr.op === '!' && type.name === 'bool' ? `aug_scalar_bool(!${operand}.as.boolean)` :
+                scalar && expr.op === '-' && ['int', 'c_int'].includes(type.name) ? `aug_scalar_int(aug_signed_bits(UINT64_C(0) - (uint64_t)${operand}.as.integer))` :
+                    scalar && expr.op === '-' && type.name === 'float' ? `(${operand}.tag == AUG_FLOAT ? aug_scalar_float(-${operand}.as.floating) : aug_unary("-", ${operand}))` : undefined;
+            this.line(`${this.slot(slot)} = ${fast ?? `aug_unary(${cString(expr.op)}, ${operand})`};`);
+            return slot;
+        }
+        if (expr.kind === 'binary') {
+            const left = this.emitExpr(expr.left);
+            if (expr.op === '&&' || expr.op === '||') {
+                const slot = this.newSlot();
+                this.line(`${this.slot(slot)} = aug_scalar_bool(${this.slot(left)}.as.boolean);`);
+                this.line(`if (${expr.op === '||' ? '!' : ''}${this.slot(slot)}.as.boolean) {`);
+                const right = this.emitExpr(expr.right);
+                this.line(`${this.slot(slot)} = aug_scalar_bool(${this.slot(right)}.as.boolean);`);
+                this.line('}');
+                return slot;
+            }
+            const right = this.emitExpr(expr.right);
+            const slot = this.newSlot();
+            this.line(`${this.slot(slot)} = ${this.scalarBinary(expr, left, right) ?? `aug_binary(${cString(expr.op)}, ${this.slot(left)}, ${this.slot(right)})`};`);
+            if (expr.op === '/')
+                this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.kind !== 'call')
+            throw new Error(`Cannot emit ${expr.kind}`);
+        if (expr.callee.kind === 'name' && expr.callee.name === 'next')
+            return this.emitNext(expr);
+        const { receiver, args } = this.emitArguments(expr);
+        return this.emitInvoke(expr, receiver, args);
+    }
+    scalarBinary(expr, left, right) {
+        const a = this.generator.expressionType(expr.left), b = this.generator.expressionType(expr.right);
+        if (!a || !b || !this.isScalar(a) || !this.isScalar(b) || a.nullable || b.nullable || a.optional || b.optional)
+            return;
+        if (a.name === 'bool' && b.name === 'bool' && ['==', '!='].includes(expr.op))
+            return `aug_scalar_bool(${this.slot(left)}.as.boolean ${expr.op} ${this.slot(right)}.as.boolean)`;
+        const numeric = (type) => ['int', 'c_int', 'float'].includes(type.name);
+        if (!numeric(a) || !numeric(b))
+            return;
+        const integer = a.name !== 'float' && b.name !== 'float';
+        const operand = (slot, type) => `${integer || type.name === 'float' ? '' : '(double)'}${this.slot(slot)}.as.${type.name === 'float' ? 'floating' : 'integer'}`;
+        const x = operand(left, a), y = operand(right, b);
+        let fast;
+        if (['==', '!=', '<', '>', '<=', '>='].includes(expr.op))
+            fast = `aug_scalar_bool(${x} ${expr.op} ${y})`;
+        else if (expr.op === '/')
+            fast = `aug_scalar_${integer ? 'int' : 'float'}_divide(${x}, ${y})`;
+        else if (['+', '-', '*'].includes(expr.op))
+            fast = integer ?
+                `aug_scalar_int(aug_signed_bits((uint64_t)${x} ${expr.op} (uint64_t)${y}))` : `aug_scalar_float(${x} ${expr.op} ${y})`;
+        if (!fast || integer)
+            return fast;
+        // Widening can leave an INT-tagged value in a statically float position.
+        // Use the existing numeric semantics until its representation is FLOAT.
+        const guards = [{ type: a, slot: left }, { type: b, slot: right }].flatMap(({ type, slot }) => type.name === 'float' ? [`${this.slot(slot)}.tag == AUG_FLOAT`] : []);
+        return `(${guards.join(' && ')} ? ${fast} : aug_binary(${cString(expr.op)}, ${this.slot(left)}, ${this.slot(right)}))`;
+    }
+    emitArguments(expr) {
+        const receiver = expr.callee.kind === 'member' ? this.emitExpr(expr.callee.object) : undefined;
+        const sourceArgs = expr.args.map(arg => this.emitExpr(arg));
+        const plan = this.generator.callPlan(expr);
+        const args = plan ? plan.sourceIndices.map((source, index) => {
+            if (source !== undefined)
+                return sourceArgs[source];
+            const dependency = plan.injectionSources?.[index];
+            if (dependency) {
+                const slot = this.newSlot();
+                if (dependency.startsWith('self.'))
+                    this.line(`${this.slot(slot)} = aug_field(${this.slot(this.locals.get('self'))}, ${this.classFields.get(dependency.slice(5))});`);
+                else
+                    this.line(`${this.slot(slot)} = ${this.slot(this.locals.get(dependency))};`);
+                return slot;
+            }
+            const slot = this.newSlot();
+            this.line(`${this.slot(slot)} = ${plan.bindingKeys[index] ? `aug_resolve_${this.generator.bindingIndex(plan.bindingKeys[index])}()` : 'aug_null()'};`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }) : sourceArgs;
+        return { receiver, args };
+    }
+    emitInvoke(expr, receiver, args) {
+        const slot = this.newSlot();
+        const array = this.label('args');
+        this.line(`AugValue ${array}[] = { ${args.map(index => this.slot(index)).join(', ') || 'aug_scalar_null()'} };`);
+        if (expr.callee.kind === 'name' && expr.callee.name === 'exit') {
+            this.line(`int aug_exit_code_${slot} = (int)aug_cint(${this.slot(args[0])});`);
+            this.line(`aug_cancelled = true; aug_shutdown(); exit(aug_exit_code_${slot} >= 0 && aug_exit_code_${slot} <= 255 ? aug_exit_code_${slot} : 1);`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'Json') {
+            this.line(`${this.slot(slot)} = aug_json_wrap(${this.slot(args[0])});`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'HttpTestClient') {
+            const endpoint = this.generator.testEndpoint();
+            const routes = this.generator.serveRoutes(endpoint.file, [endpoint.name]);
+            this.line(`${this.slot(slot)} = aug_http_test_client(${routes}, ${this.generator.serveRouteCount(1)});`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'Shared') {
+            this.line(`${this.slot(slot)} = aug_shared_new(${this.slot(args[0])});`);
+            if (expr.args[0]?.kind === 'name') {
+                const source = this.locals.get(expr.args[0].name);
+                if (source !== undefined && this.owned.has(source))
+                    this.line(`${this.slot(source)} = aug_scalar_null();`);
+            }
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'ServerEvent') {
+            this.line(`${this.slot(slot)} = aug_http_event(${args.map(arg => this.slot(arg)).join(', ')});`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && ['Headers', 'HttpResponse'].includes(expr.callee.name)) {
+            this.line(`${this.slot(slot)} = ${expr.callee.name === 'Headers' ? 'aug_headers_new()' : `aug_http_response_full(${this.slot(args[0])}, ${this.slot(args[1])}, ${this.slot(args[2])})`};`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && ['c_int', 'int'].includes(expr.callee.name)) {
+            this.line(`${this.slot(slot)} = ${expr.callee.name === 'c_int' ? `aug_to_c_int(${this.slot(args[0])})` : this.slot(args[0])};`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'print') {
+            if (args[0] !== undefined)
+                this.line(`aug_print(${this.slot(args[0])});`);
+            this.line(`${this.slot(slot)} = aug_scalar_null();`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'assert') {
+            this.line(`aug_assert(${this.slot(args[0])}, ${cString(this.generator.expressionSource(expr.args[0]))}, ${cString(expr.span.file)}, ${expr.span.line});`);
+            this.line(`${this.slot(slot)} = aug_scalar_null();`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'arguments') {
+            this.line(`${this.slot(slot)} = aug_arguments();`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'read_file') {
+            this.line(`${this.slot(slot)} = aug_read_file(${this.slot(args[0])});`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'write_file') {
+            this.line(`${this.slot(slot)} = aug_write_file(${this.slot(args[0])}, ${this.slot(args[1])});`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && ['List', 'Set', 'Tuple'].includes(expr.callee.name)) {
+            this.line(`${this.slot(slot)} = aug_${expr.callee.name.toLowerCase()}_new(${array}, ${args.length});`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && expr.callee.name === 'Map') {
+            this.line(`${this.slot(slot)} = aug_map_new();`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name' && errorNames.includes(expr.callee.name)) {
+            this.line(`${this.slot(slot)} = aug_new_object(${cString(expr.callee.name)}, 0, NULL, NULL, 0);`);
+            return slot;
+        }
+        if (expr.callee.kind === 'name') {
+            const def = this.generator.definition(this.file, expr.callee.name);
+            if (def?.node.kind === 'class') {
+                this.line(`${this.slot(slot)} = ${this.generator.cConstructor(def)}(${array}, ${args.length});`);
+                this.clearMovedArgs(expr, def.node.fields);
+            }
+            else if (def?.node.kind === 'function') {
+                if (def.node.externC && !this.generator.hasInterceptors(def.node))
+                    this.emitExternCall(def, args, slot);
+                else
+                    this.line(`${this.slot(slot)} = ${this.generator.cName(def)}(${array}, ${args.length});`);
+                this.clearMovedArgs(expr, def.node.params);
+            }
+        }
+        else if (expr.callee.kind === 'member') {
+            const methodName = expr.callee.name;
+            const type = this.generator.expressionType(expr.callee.object);
+            const operation = type && collectionOperations[type.name]?.find(operation => operation.name === methodName);
+            if (operation) {
+                if (type.name === 'Json' && methodName === 'decode' || type.name === 'HttpRequest' && methodName === 'form') {
+                    this.line(`${this.slot(slot)} = ${methodName === 'form' ? 'aug_httprequest_form' : 'aug_json_decode'}(${this.slot(receiver)}, &${this.generator.schema(this.generator.expressionType(expr))});`);
+                    this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+                    return slot;
+                }
+                const values = [this.slot(receiver), ...args.map((index, position) => operation.parameters[position]?.type === 'int' ? `aug_cint(${this.slot(index)})` : this.slot(index))];
+                const call = `aug_${type.name.toLowerCase()}_${operation.native}(${values.join(', ')})`;
+                if (operation.returns === 'void') {
+                    this.line(`${call};`);
+                    this.line(`${this.slot(slot)} = aug_scalar_null();`);
+                }
+                else
+                    this.line(`${this.slot(slot)} = ${operation.returns === 'bool' ? `aug_scalar_bool(${call})` : operation.returns === 'int' ? `aug_scalar_int(${call})` : call};`);
+            }
+            else {
+                this.line(`${this.slot(slot)} = aug_call_method(${this.slot(receiver)}, ${cString(methodName)}, ${array}, ${args.length});`);
+                const node = type?.def?.node;
+                const method = node?.kind === 'class' || node?.kind === 'interface' || node?.kind === 'interceptor' ?
+                    node.methods.find(item => item.name === methodName) : undefined;
+                if (method)
+                    this.clearMovedArgs(expr, method.params);
+            }
+        }
+        this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+        return slot;
+    }
+    clearMovedArgs(call, params) {
+        const plan = this.generator.callPlan(call);
+        params.forEach((param, index) => {
+            const source = plan ? plan.sourceIndices[index] : index;
+            if (source === undefined || param.ownership !== 'own' ||
+                call.args[source]?.kind !== 'name')
+                return;
+            const name = call.args[source].name;
+            const slot = this.locals.get(name);
+            if (slot !== undefined && this.owned.has(slot))
+                this.line(`${this.slot(slot)} = aug_scalar_null();`);
+        });
+    }
+    emitExternCall(def, args, output) {
+        const fn = def.node;
+        if (fn.valueAbi) {
+            this.line(`${this.slot(output)} = ${fn.name}(${args.map(index => this.slot(index)).join(', ')});`);
+            return;
+        }
+        const values = args.map((index, i) => {
+            const type = fn.params[i]?.type.name;
+            return type === 'string' ? `aug_cstring(${this.slot(index)})` :
+                type === 'int' ? `aug_cint(${this.slot(index)})` : type === 'c_int' ? `(int)aug_cint(${this.slot(index)})` :
+                    type === 'float' ? `aug_cfloat(${this.slot(index)})` :
+                        type === 'bool' ? `aug_truthy(${this.slot(index)})` : this.slot(index);
+        });
+        const call = `${fn.name}(${values.join(', ')})`;
+        const convert = fn.returns.name === 'void' ? `${call}; ${this.slot(output)} = aug_scalar_null()` :
+            fn.returns.name === 'string' ? `aug_string(${call})` :
+                ['int', 'c_int'].includes(fn.returns.name) ? `aug_scalar_int(${call})` :
+                    fn.returns.name === 'float' ? `aug_scalar_float(${call})` : `aug_scalar_bool(${call})`;
+        this.line(fn.returns.name === 'void' ? `${convert};` : `${this.slot(output)} = ${convert};`);
+    }
+    beginTestCase() { this.line('aug_test_assertions = 0;'); }
+    emitStatement(stmt) {
+        if (stmt.kind === 'lock') {
+            const value = this.emitExpr(stmt.value), slot = this.newSlot();
+            const names = new Map(this.locals);
+            this.locals.set(stmt.name, slot);
+            this.line(`${this.slot(slot)} = aug_shared_lock(${this.slot(value)});`);
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            this.emitScoped(stmt.body);
+            this.line('aug_lock_leave();');
+            this.locals = names;
+            return;
+        }
+        this.line(`#line ${stmt.span.line} ${cString(stmt.span.file)}`);
+        if (this.generator.coveragePoint(stmt))
+            this.line(`aug_cover(${cString(stmt.span.file)}, ${stmt.span.line});`);
+        if (stmt.kind === 'serve') {
+            const port = this.emitExpr(stmt.port), routes = this.generator.serveRoutes(this.file, stmt.names);
+            this.line(`aug_http_serve(${routes}, ${this.generator.serveRouteCount(stmt.names.length)}, aug_cint(${this.slot(port)}));`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return;
+        }
+        if (stmt.kind === 'freeze') {
+            const value = this.emitExpr(stmt.value);
+            this.line(`aug_freeze(${this.slot(value)});`);
+            const slot = this.newSlot();
+            this.locals.set(stmt.name, slot);
+            this.line(`${this.slot(slot)} = ${this.slot(value)};`);
+            if (stmt.value.kind === 'name') {
+                const source = this.locals.get(stmt.value.name);
+                if (source !== undefined)
+                    this.owned.delete(source);
+            }
+            return;
+        }
+        if (stmt.kind === 'expr') {
+            this.emitExpr(stmt.expr);
+            return;
+        }
+        if (stmt.kind === 'destructure') {
+            const value = this.emitExpr(stmt.value);
+            for (const [index, name] of stmt.names.entries()) {
+                const slot = this.newSlot();
+                this.locals.set(name, slot);
+                this.line(`${this.slot(slot)} = aug_tuple_get(${this.slot(value)}, ${index});`);
+            }
+            return;
+        }
+        if (stmt.kind === 'for') {
+            const value = this.emitExpr(stmt.iterable);
+            const snapshot = this.newSlot();
+            const iterableType = this.generator.expressionType(stmt.iterable);
+            const flatMap = stmt.names.length === 2 && iterableType?.kind === 'builtin' && iterableType.name === 'Map';
+            this.line(`${this.slot(snapshot)} = ${flatMap ? 'aug_map_entries_snapshot' : 'aug_iter_snapshot'}(${this.slot(value)});`);
+            const index = this.label('aug_index');
+            const names = new Map(this.locals);
+            const slots = stmt.names.map(name => { const slot = this.newSlot(); this.locals.set(name, slot); return slot; });
+            if (flatMap)
+                slots.forEach((slot, index) => {
+                    if (this.isScalar(this.generator.expressionType(stmt.iterable)?.args[index]))
+                        this.scalarSlots.add(slot);
+                });
+            this.line(`for (size_t ${index} = 0; ${index} < ${this.slot(snapshot)}.as.object->field_count${flatMap ? ' / 2' : ''}; ${index}++) {`);
+            this.line('if (aug_execution->fiber || aug_task_checkpoint_hook) aug_task_checkpoint();');
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+            if (flatMap)
+                slots.forEach((slot, position) => this.line(`${this.slot(slot)} = ${this.slot(snapshot)}.as.object->fields[${index} * 2 + ${position}];`));
+            else {
+                const item = this.newSlot();
+                this.line(`${this.slot(item)} = ${this.slot(snapshot)}.as.object->fields[${index}];`);
+                slots.forEach((slot, position) => this.line(`${this.slot(slot)} = ${slots.length === 1 ? this.slot(item) : `aug_tuple_get(${this.slot(item)}, ${position})`};`));
+            }
+            this.emitScoped(stmt.body);
+            this.line('}');
+            this.locals = names;
+            return;
+        }
+        if (stmt.kind === 'match') {
+            const value = this.emitExpr(stmt.value);
+            const literals = stmt.cases.map(clause => clause.literal ? this.emitExpr(clause.literal) : undefined);
+            for (const [index, clause] of stmt.cases.entries()) {
+                const literal = literals[index];
+                const type = clause.type ? this.generator.definition(this.file, clause.type.name) : undefined;
+                const condition = clause.pattern === 'else' ? '1' : clause.pattern === 'null' ? `${this.slot(value)}.tag == AUG_NULL` :
+                    clause.pattern === 'some' ? `${this.slot(value)}.tag != AUG_NULL` : clause.pattern === 'type' ?
+                        `${this.slot(value)}.tag == AUG_OBJECT && !strcmp(${this.slot(value)}.as.object->type_name, ${cString(type?.node.kind === 'class' && type.node.record ? type.id : clause.type.name)})` :
+                        `aug_truthy(aug_binary("==", ${this.slot(value)}, ${this.slot(literal)}))`;
+                this.line(`${index ? 'else ' : ''}if (${condition}) {`);
+                const names = new Map(this.locals);
+                if (clause.name)
+                    this.locals.set(clause.name, value);
+                this.emitScoped(clause.body);
+                this.locals = names;
+                this.line('}');
+            }
+            return;
+        }
+        if (stmt.kind === 'assign') {
+            const value = this.emitExpr(stmt.value);
+            const sourceSlot = stmt.value.kind === 'name' ? this.locals.get(stmt.value.name) : undefined;
+            if (stmt.target.kind === 'name') {
+                const existing = this.locals.get(stmt.target.name);
+                if (existing !== undefined)
+                    this.line(`${this.slot(existing)} = ${this.slot(value)};`);
+                else if (this.classFields.has(stmt.target.name))
+                    this.line(`aug_set_field(${this.slot(this.locals.get('self'))}, ${this.classFields.get(stmt.target.name)}, ${this.slot(value)});`);
+                else {
+                    const target = this.newSlot();
+                    this.locals.set(stmt.target.name, target);
+                    this.line(`${this.slot(target)} = ${this.slot(value)};`);
+                    if (this.isScalar(this.generator.expressionType(stmt.value)) && (!stmt.declaredType || ['int', 'c_int', 'float', 'bool'].includes(stmt.declaredType.name)))
+                        this.scalarSlots.add(target);
+                    if (stmt.ownership === 'own')
+                        this.owned.add(target);
+                }
+            }
+            else if (stmt.target.kind === 'member') {
+                const object = this.emitExpr(stmt.target.object);
+                this.line(`aug_set_field(${this.slot(object)}, ${this.memberIndex(stmt.target.object, stmt.target.name)}, ${this.slot(value)});`);
+            }
+            let targetOwns = stmt.ownership === 'own';
+            if (stmt.target.kind === 'member') {
+                const memberName = stmt.target.name;
+                const node = this.generator.expressionType(stmt.target.object)?.def?.node;
+                targetOwns ||= (node?.kind === 'class' || node?.kind === 'interceptor') && !!fieldsOf(node).find(field => field.name === memberName && field.ownership === 'own');
+            }
+            if (sourceSlot !== undefined && this.owned.has(sourceSlot) && targetOwns)
+                this.line(`${this.slot(sourceSlot)} = aug_scalar_null();`);
+            return;
+        }
+        if (stmt.kind === 'yield') {
+            const value = this.emitExpr(stmt.value);
+            this.line(`aug_http_yield(${this.slot(value)});`);
+            this.line(`if (aug_has_error || aug_cancelled) goto ${this.errorTarget};`);
+            return;
+        }
+        if (stmt.kind === 'return') {
+            const value = stmt.value ? this.emitExpr(stmt.value) : undefined;
+            this.line(`${this.slot(0)} = ${value === undefined ? 'aug_scalar_null()' : this.slot(value)};`);
+            if (value !== undefined && this.owned.has(value))
+                this.line(`${this.slot(value)} = aug_scalar_null();`);
+            this.line(`goto ${this.returnTarget};`);
+            return;
+        }
+        if (stmt.kind === 'throw') {
+            const value = this.emitExpr(stmt.value);
+            this.line(`aug_throw(${this.slot(value)});`);
+            if (this.owned.has(value))
+                this.line(`${this.slot(value)} = aug_scalar_null();`);
+            this.line(`goto ${this.errorTarget};`);
+            return;
+        }
+        if (stmt.kind === 'if') {
+            const condition = this.emitExpr(stmt.test);
+            this.line(`if (${this.slot(condition)}.as.boolean) {`);
+            this.emitScoped(stmt.then);
+            this.line('} else {');
+            this.emitScoped(stmt.otherwise);
+            this.line('}');
+            return;
+        }
+        if (stmt.kind === 'while') {
+            this.line('while (1) {');
+            this.line('if (aug_execution->fiber || aug_task_checkpoint_hook) aug_task_checkpoint();');
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+            const condition = this.emitExpr(stmt.test);
+            this.line(`if (!${this.slot(condition)}.as.boolean) break;`);
+            this.emitScoped(stmt.body);
+            this.line('}');
+            return;
+        }
+        if (stmt.kind === 'scope') {
+            this.line('aug_scope_enter(aug_scoped);');
+            this.line('{');
+            this.emitScoped(stmt.body, true);
+            this.line('}');
+            this.line('aug_scope_leave();');
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            return;
+        }
+        if (stmt.kind === 'unsafe' || stmt.kind === 'borrow') {
+            this.line('{');
+            this.emitScoped(stmt.body);
+            this.line('}');
+            return;
+        }
+        if (stmt.kind === 'try') {
+            if (stmt.always) {
+                this.emitTryAlways(stmt);
+                return;
+            }
+            const catchLabel = this.label('aug_catch');
+            const afterLabel = this.label('aug_after_catch');
+            const outerTarget = this.errorTarget;
+            const ownedBefore = new Set(this.owned);
+            const scopeDepth = this.label('aug_catch_depth');
+            const lockDepth = this.label('aug_catch_locks');
+            this.line(`size_t ${scopeDepth} = aug_scope_depth();`);
+            this.line(`size_t ${lockDepth} = aug_lock_depth();`);
+            this.errorTarget = catchLabel;
+            this.line('{');
+            this.emitScoped(stmt.body);
+            this.line('}');
+            this.errorTarget = outerTarget;
+            this.line(`goto ${afterLabel};`);
+            this.line(`${catchLabel}:;`);
+            this.line(`aug_scope_restore(${scopeDepth});`);
+            this.line(`aug_lock_restore(${lockDepth});`);
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+            for (const slot of this.owned)
+                if (!ownedBefore.has(slot))
+                    this.line(`if (${this.slot(slot)}.tag != AUG_NULL) { aug_drop(${this.slot(slot)}); ${this.slot(slot)} = aug_scalar_null(); }`);
+            for (const clause of stmt.catches) {
+                this.line(`if (aug_error_is(${cString(clause.type.name)})) {`);
+                const slot = this.newSlot();
+                const prior = this.locals.get(clause.name);
+                this.locals.set(clause.name, slot);
+                this.line(`${this.slot(slot)} = aug_take_error();`);
+                this.emitScoped(clause.body);
+                if (prior === undefined)
+                    this.locals.delete(clause.name);
+                else
+                    this.locals.set(clause.name, prior);
+                this.line(`goto ${afterLabel};`);
+                this.line('}');
+            }
+            this.line(`goto ${outerTarget};`);
+            this.line(`${afterLabel}:;`);
+        }
+    }
+    emitTryAlways(stmt) {
+        const outerError = this.errorTarget, outerReturn = this.returnTarget;
+        const caught = this.label('aug_final_catch'), failed = this.label('aug_final_error'), returned = this.label('aug_final_return');
+        const cleanup = this.label('aug_always'), done = this.label('aug_always_done'), after = this.label('aug_always_after');
+        const reason = this.label('aug_exit_reason'), depth = this.label('aug_final_depth'), cancellation = this.label('aug_final_cancel');
+        const locks = this.label('aug_final_locks');
+        const pending = this.newSlot();
+        this.line(`int ${reason} = 0; size_t ${depth} = aug_scope_depth(); bool ${cancellation} = false;`);
+        this.line(`size_t ${locks} = aug_lock_depth();`);
+        this.errorTarget = caught;
+        this.returnTarget = returned;
+        this.emitScoped(stmt.body);
+        this.line(`goto ${cleanup};`);
+        this.line(`${caught}:;`);
+        this.line(`aug_scope_restore(${depth}); if (aug_cancelled) goto ${failed};`);
+        this.line(`aug_lock_restore(${locks});`);
+        this.errorTarget = failed;
+        for (const clause of stmt.catches) {
+            this.line(`if (aug_error_is(${cString(clause.type.name)})) {`);
+            const names = new Map(this.locals), slot = this.newSlot();
+            this.locals.set(clause.name, slot);
+            this.line(`${this.slot(slot)} = aug_take_error();`);
+            this.emitScoped(clause.body);
+            this.locals = names;
+            this.line(`goto ${cleanup};`);
+            this.line('}');
+        }
+        this.line(`goto ${failed};`);
+        this.line(`${returned}: ${reason} = 1; goto ${cleanup};`);
+        this.line(`${failed}: ${reason} = 2;`);
+        this.line(`${cleanup}:;`);
+        this.line(`aug_scope_restore(${depth}); ${this.slot(pending)} = aug_has_error ? aug_take_error() : aug_scalar_null();`);
+        this.line(`aug_lock_restore(${locks});`);
+        this.line(`${cancellation} = aug_cancelled; aug_cancelled = false;`);
+        this.errorTarget = done;
+        this.returnTarget = done;
+        this.emitScoped(stmt.always);
+        this.line(`${done}:; aug_cancelled = ${cancellation};`);
+        this.line(`if (!aug_has_error && ${this.slot(pending)}.tag != AUG_NULL) aug_throw(${this.slot(pending)});`);
+        this.line(`if (aug_cancelled || ${reason} == 1) goto ${outerReturn};`);
+        this.line(`if (aug_has_error || ${reason} == 2) goto ${outerError};`);
+        this.line(`goto ${after}; ${after}:;`);
+        this.errorTarget = outerError;
+        this.returnTarget = outerReturn;
+    }
+    emitScoped(body, joinBeforeDrop = false) {
+        const names = new Set(this.locals.keys());
+        const owned = new Set(this.owned);
+        for (const stmt of body)
+            this.emitStatement(stmt);
+        const endingOwned = [...this.owned].filter(slot => !owned.has(slot));
+        if (joinBeforeDrop && endingOwned.length)
+            this.line('aug_scope_join_to(aug_scope_depth() - 1);');
+        for (const slot of endingOwned) {
+            this.line(`aug_drop(${this.slot(slot)}); ${this.slot(slot)} = aug_scalar_null();`);
+        }
+        if (endingOwned.length) {
+            this.line(`if (aug_has_error) goto ${this.errorTarget};`);
+            this.line(`if (aug_cancelled) goto ${this.returnTarget};`);
+        }
+        for (const name of this.locals.keys())
+            if (!names.has(name))
+                this.locals.delete(name);
+    }
+    finish(name, method, paramCount) {
+        const body = this.lines.map(line => `  ${line}`).join('\n')
+            // Match complete C strings first so source text and #line paths are never
+            // interpreted as generated identifiers or slot references.
+            .replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\broots\[(\d+)\]|\baug_has_error\b|\baug_cancelled\b/g, (token, index) => {
+            if (index !== undefined)
+                return this.scalarSlots.has(Number(index)) ? `scalar_${index}` : token;
+            if (token === 'aug_has_error')
+                return 'aug_execution->has_error';
+            if (token === 'aug_cancelled')
+                return 'aug_execution->cancelled';
+            return token;
+        });
+        const ownedCleanup = [...this.owned].map(slot => `  if (${this.slot(slot)}.tag != AUG_NULL) { aug_drop(${this.slot(slot)}); ${this.slot(slot)} = aug_scalar_null(); }`).join('\n');
+        return [
+            `static AugValue ${name}(${method ? 'AugValue self, ' : ''}AugValue *args, int count) {`,
+            `  (void)args; (void)count;`,
+            `  AugExecution *aug_execution = aug_execution_current();`,
+            ...[...this.scalarSlots].map(slot => `  AugValue scalar_${slot} = {0};`),
+            `  AugValue roots[${Math.max(1, this.slots)}] = {0};`,
+            `  AugFrame frame; aug_frame_enter(&frame, roots, ${Math.max(1, this.slots)});`,
+            `  size_t aug_scope_base = aug_scope_depth();`,
+            `  size_t aug_lock_base = aug_lock_depth();`,
+            `  ${this.slot(0)} = aug_scalar_null();`,
+            body,
+            `aug_cleanup:;`,
+            `  aug_lock_restore(aug_lock_base);`,
+            `  aug_scope_join_to(aug_scope_base);`,
+            ownedCleanup,
+            `  aug_scope_restore(aug_scope_base);`,
+            `  AugValue result = ${this.slot(0)};`,
+            `  aug_frame_leave(&frame);`,
+            `  return result;`,
+            `}`,
+        ].join('\n');
+    }
+}