@greenpandastudios/aug-cli 0.19.0 → 0.21.0

package/src/cli.js

@@ -4,6 +4,13 @@ import { spawnSync } from 'node:child_process';
 import { typeName } from "./ast.js";
 import { checkProject } from "./checker.js";
 import { generateC } from "./codegen.js";
+import { generateLLVM } from "./llvm.js";
+import { lowerToIR, BackendUnsupported } from "./ir.js";
+import { IRVerificationError } from "./ir-verify.js";
+import { compileLLVM } from "./llvm-native.js";
+import { prepareNativePackages } from "./native-artifacts.js";
+import { prepareLLVMCompiler } from "./compiler-packs.js";
+import { bindNativeHeader } from "./native-bindings.js";
 import { diagnosticHelp } from "./help.js";
 import { loadProject } from "./project.js";
 import { definitionAt } from "./navigation.js";
@@ -11,26 +18,54 @@ import { checkUnitTests, discoverTests, mergeTestAnalysis, uniqueDiagnostics } f
 import { describe, SemanticWorkspace } from "./semantic.js";
 import { formatFile, migrateFile } from "./formatter.js";
 import { updateSpecs } from "./spec.js";
+import { updateSpecHints } from "./spec-hints.js";
 import { runLanguageServer } from "./lsp.js";
 import { benchmark, compileNative, writeCoverage } from "./native.js";
 import { generateOpenApi } from "./openapi.js";
-import { initPackage, installPackages, preparePackage, packPackage } from "./package-manager.js";
+import { addPackage, initPackage, installPackages, preparePackage, packPackage, prepareRunPackages } from "./package-manager.js";
 import { initProject } from "./project-init.js";
+import { prepareNativeDependencies } from '../scripts/native-setup.mjs';
+function failureMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof Error && 'code' in error && ['EACCES', 'EPERM', 'EROFS'].includes(String(error.code)))
+        return `${message}\nAugust needs a writable project and native cache. Check the folder permissions, or set AUG_NATIVE_HOME to a directory you own.`;
+    if (error instanceof Error && 'code' in error && error.code === 'ENOSPC')
+        return `${message}\nThere is not enough disk space to compile or prepare dependencies. Free space and retry aug run.`;
+    return message;
+}
 function printDiagnostics(diagnostics, json, root) {
     if (json) {
         process.stdout.write(JSON.stringify(diagnostics.map(issue => ({ ...issue,
             help: diagnosticHelp[issue.code] }))) + '\n');
         return;
     }
+    const sources = new Map();
     for (const issue of diagnostics) {
-        const file = issue.file.startsWith(root) ? issue.file.slice(root.length + 1) : issue.file;
+        const file = relative(root, issue.file) || issue.file;
         process.stderr.write(`${file}:${issue.line}:${issue.column}: ${issue.code}: ${issue.message}\n`);
+        try {
+            if (!sources.has(issue.file))
+                sources.set(issue.file, readFileSync(issue.file, 'utf8').split(/\r?\n/));
+            const line = sources.get(issue.file)?.[issue.line - 1];
+            if (line !== undefined) {
+                const column = Math.max(0, Math.min(line.length, issue.column - 1));
+                const start = Math.max(0, column - 70), end = Math.min(line.length, start + 150);
+                const text = (start ? '…' : '') + line.slice(start, end).replace(/\t/g, '    ') + (end < line.length ? '…' : '');
+                const padding = (start ? 1 : 0) + line.slice(start, column).replace(/\t/g, '    ').length;
+                process.stderr.write(`  ${issue.line} | ${text}\n  ${' '.repeat(String(issue.line).length)} | ${' '.repeat(padding)}^\n`);
+            }
+        }
+        catch { /* Source may have been removed; the location and help remain useful. */ }
+        if (diagnosticHelp[issue.code])
+            process.stderr.write(`  help: ${diagnosticHelp[issue.code]}\n`);
     }
 }
 function usage() {
     process.stdout.write(`AugScript compiler\n\n` +
-        `Usage: aug <init|check|build|run|emit-c|test|openapi|format|migrate|spec|bench|explain|context|lsp|symbols|definition|complete|hover|fixes|semantic-tokens> [project directory] [options] [-- args]\n` +
-        `New application: aug init DIRECTORY\n` +
+        `Usage: aug <init|check|build|run|emit-c|emit-llvm|emit-ir|test|openapi|format|migrate|spec|bench|explain|context|lsp|symbols|definition|complete|hover|fixes|semantic-tokens> [project directory] [options] [-- args]\n` +
+        `New application: aug init DIRECTORY [--template hello|weather]\n` +
+        `Run: aug run [project directory] [--offline] [-- args] — prepare dependencies, compile, and start\n` +
+        `Backend: LLVM is the default on macOS 14+ ARM64 and GNU/Linux x64/ARM64 with glibc 2.36+. August installs its compiler pack; no separate native toolchain is needed. --backend c selects the migration reference.\n` +
         `Tests: aug test [project directory] [GROUP_NAME] [--group GROUP_NAME] [--list] [--coverage] [--json] [--timeout milliseconds]\n` +
         `Format: aug format [project directory] [--file path] [--write]\n` +
         `Specifications: aug spec [project directory] [--check] [--json]\n` +
@@ -38,7 +73,8 @@ function usage() {
         `Context: aug context [project directory] [--file path] [--name declaration] [--budget characters]\n` +
         `Benchmark: aug bench [project directory] [--iterations 10] [--warmup 2] [--json] [-- args]\n` +
         `Packages: aug package init DIRECTORY --name @owner/name; aug package pack DIRECTORY\n` +
-        `Dependencies: aug install [project directory] [--frozen] [--offline]\n` +
+        `Dependencies: aug add URL --as NAME [--project DIRECTORY]; aug install [project directory] [--frozen|--update] [--offline]\n` +
+        `Native maintainers: aug bind header HEADER --contract native.abi.json --target TRIPLE --output DIRECTORY --clang PATH [-- CLANG_FLAGS]\n` +
         `Entry point: main.aug at the project root.\n`);
 }
 export async function main(argv) {
@@ -53,18 +89,75 @@ export async function main(argv) {
         usage();
         return 0;
     }
+    if (command === 'bind') {
+        const boundary = argv.indexOf('--'), arguments_ = boundary < 0 ? argv : argv.slice(0, boundary), values = {};
+        if (arguments_[1] !== 'header' || !arguments_[2] || arguments_[2].startsWith('--')) {
+            process.stderr.write('Use aug bind header HEADER --contract FILE --target TRIPLE --output DIRECTORY --clang PATH\n');
+            return 2;
+        }
+        for (let index = 3; index < arguments_.length; index++) {
+            const flag = arguments_[index];
+            if (!['--contract', '--target', '--output', '--clang'].includes(flag) || values[flag] !== undefined || !arguments_[index + 1] || arguments_[index + 1].startsWith('--')) {
+                process.stderr.write('Invalid or duplicate native binding option: ' + flag + '\n');
+                return 2;
+            }
+            values[flag] = arguments_[++index];
+        }
+        if (['--contract', '--target', '--output', '--clang'].some(flag => !values[flag])) {
+            process.stderr.write('Native header validation requires --contract, --target, --output and --clang. No tool is installed automatically.\n');
+            return 2;
+        }
+        try {
+            bindNativeHeader({ header: arguments_[2], contract: values['--contract'], target: values['--target'], output: values['--output'], clang: values['--clang'], flags: boundary < 0 ? [] : argv.slice(boundary + 1) });
+            process.stdout.write('Checked native declarations written to ' + resolve(values['--output']) + '\n');
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(failureMessage(error) + '\n');
+            return 1;
+        }
+    }
+    if (command === 'add') {
+        const aliasIndex = argv.indexOf('--as'), projectIndex = argv.indexOf('--project');
+        if (!argv[1] || argv[1].startsWith('--') || aliasIndex < 0 || !argv[aliasIndex + 1]) {
+            process.stderr.write('Use aug add URL --as NAME [--project DIRECTORY] [--offline]\n');
+            return 2;
+        }
+        for (let index = 2; index < argv.length; index++) {
+            if (['--as', '--project'].includes(argv[index])) {
+                if (!argv[++index] || argv[index].startsWith('--'))
+                    return 2;
+            }
+            else if (argv[index] !== '--offline') {
+                process.stderr.write('Unknown add option: ' + argv[index] + '\n');
+                return 2;
+            }
+        }
+        try {
+            const alias = argv[aliasIndex + 1], root = resolve(projectIndex < 0 ? process.cwd() : argv[projectIndex + 1]);
+            const lock = addPackage(root, argv[1], alias, argv.includes('--offline'));
+            await prepareNativePackages(root, { offline: argv.includes('--offline') });
+            process.stdout.write(`Added ${alias}; installed ${lock.packages.length} source package(s).\nImport public names with: import NAME from ${alias}\n`);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(failureMessage(error) + '\n');
+            return 1;
+        }
+    }
     if (command === 'init') {
-        if (argv.length !== 2 || !argv[1] || argv[1].startsWith('--')) {
-            process.stderr.write('Use aug init DIRECTORY\n');
+        const template = argv.length === 2 ? 'hello' : argv[2] === '--template' && argv.length === 4 ? argv[3] : undefined;
+        if (!argv[1] || argv[1].startsWith('--') || !['hello', 'weather'].includes(template ?? '')) {
+            process.stderr.write('Use aug init DIRECTORY [--template hello|weather]\n');
             return 2;
         }
         try {
-            const root = initProject(argv[1]);
-            process.stdout.write(`Created August application in ${root}\nNext: cd ${argv[1]} && aug check . && aug test . && aug run .\n`);
+            const root = initProject(argv[1], template);
+            process.stdout.write(`Created August application in ${root}\nNext: cd ${argv[1]}\n      aug run\n`);
             return 0;
         }
         catch (error) {
-            process.stderr.write(error.message + '\n');
+            process.stderr.write(failureMessage(error) + '\n');
             return 1;
         }
     }
@@ -73,17 +166,19 @@ export async function main(argv) {
             const root = resolve((command === 'install' ? argv[1] : argv[2]) && !(command === 'install' ? argv[1] : argv[2]).startsWith('--')
                 ? (command === 'install' ? argv[1] : argv[2]) : process.cwd());
             if (command === 'install') {
-                const lock = installPackages(root, argv.includes('--frozen'), argv.includes('--offline'));
+                const lock = installPackages(root, argv.includes('--frozen'), argv.includes('--offline'), argv.includes('--update'));
+                await prepareNativePackages(root, { offline: argv.includes('--offline'), frozen: argv.includes('--frozen') });
                 process.stdout.write(`Installed ${lock.packages.length} August package(s); aug.lock.json is current.\n`);
             }
             else if (argv[1] === 'init') {
-                const name = argv[argv.indexOf('--name') + 1];
-                if (!argv.includes('--name') || !name)
-                    throw new Error('Use aug package init DIRECTORY --name @owner/name');
-                initPackage(root, name);
+                const name = argv.includes('--name') ? argv[argv.indexOf('--name') + 1] : root.split(/[\\/]/).at(-1);
+                if (!name)
+                    throw new Error('Use aug package init DIRECTORY [--name @owner/name]');
+                initPackage(root, name, argv.includes('--name'));
                 process.stdout.write(`Created August library ${name} in ${root}\n`);
             }
             else if (argv[1] === 'pack') {
+                prepareRunPackages(root);
                 preparePackage(root);
                 const project = loadProject(root), checked = checkProject(project);
                 const tests = checkUnitTests(project, discoverTests(project).tests);
@@ -101,13 +196,13 @@ export async function main(argv) {
             return 0;
         }
         catch (error) {
-            process.stderr.write(error.message + '\n');
+            process.stderr.write(failureMessage(error) + '\n');
             return 1;
         }
     }
     if (command === 'lsp')
         return runLanguageServer(resolve(argv[1] ?? process.cwd()));
-    if (!['check', 'build', 'run', 'emit-c', 'test', 'openapi', 'format', 'migrate', 'spec', 'bench', 'explain', 'context', 'symbols', 'definition',
+    if (!['check', 'build', 'run', 'emit-c', 'emit-llvm', 'emit-ir', 'test', 'openapi', 'format', 'migrate', 'spec', 'bench', 'explain', 'context', 'symbols', 'definition',
         'complete', 'hover', 'fixes', 'semantic-tokens'].includes(command)) {
         process.stderr.write(`Unknown command ${command}\n`);
         usage();
@@ -116,7 +211,33 @@ export async function main(argv) {
     const separator = argv.indexOf('--');
     const options = separator >= 0 ? argv.slice(1, separator) : argv.slice(1);
     const programArgs = separator >= 0 ? argv.slice(separator + 1) : [];
+    if (options.includes('--help')) {
+        usage();
+        return 0;
+    }
+    const valueOptions = new Set(['--backend', '--out', '--stdin-file', '--file', '--name', '--offset', '--budget', '--baseline', '--group', '--case', '--timeout', '--iterations', '--warmup']);
+    const booleanOptions = new Set(['--json', '--coverage', '--list', '--write', '--check', '--offline', '--frozen']);
+    for (let index = 0; index < options.length; index++) {
+        const option = options[index];
+        if (valueOptions.has(option)) {
+            if (!options[index + 1] || options[index + 1].startsWith('--')) {
+                process.stderr.write(`${option} needs a value. See aug ${command} --help.\n`);
+                return 2;
+            }
+            index++;
+        }
+        else if (option.startsWith('-') && !booleanOptions.has(option)) {
+            process.stderr.write(`Unknown option ${option}. See aug ${command} --help. To pass an option to your program, put it after --.\n`);
+            return 2;
+        }
+    }
     const json = options.includes('--json');
+    const backendIndex = options.indexOf('--backend');
+    let backend = backendIndex < 0 ? 'llvm' : options[backendIndex + 1];
+    if (!['c', 'llvm'].includes(backend)) {
+        process.stderr.write('--backend must be c or llvm\n');
+        return 2;
+    }
     const outIndex = options.indexOf('--out');
     const outputOption = outIndex >= 0 ? options[outIndex + 1] : undefined;
     const stdinIndex = options.indexOf('--stdin-file');
@@ -141,6 +262,7 @@ export async function main(argv) {
     const iterations = iterationsIndex >= 0 ? Number(options[iterationsIndex + 1]) : 10;
     const warmup = warmupIndex >= 0 ? Number(options[warmupIndex + 1]) : 2;
     const positionals = options.filter((arg, i) => !arg.startsWith('--') &&
+        (backendIndex < 0 || i !== backendIndex + 1) &&
         (outIndex < 0 || i !== outIndex + 1) &&
         (stdinIndex < 0 || i !== stdinIndex + 1) &&
         (fileIndex < 0 || i !== fileIndex + 1) &&
@@ -171,7 +293,13 @@ export async function main(argv) {
             process.stdout.write(JSON.stringify(result) + '\n');
             return 0;
         }
+        if (!existsSync(root) || !statSync(root).isDirectory())
+            throw new Error(`Project directory does not exist: ${root}\nUse aug init DIRECTORY to create a project, or run aug run from the folder containing main.aug.`);
+        if (command === 'run')
+            prepareRunPackages(root, options.includes('--offline'), options.includes('--frozen'));
         const project = loadProject(root, overrides);
+        if (backendIndex < 0)
+            backend = project.config.backend ?? 'llvm';
         if (project.library && ['build', 'run', 'bench', 'openapi'].includes(command))
             throw new Error('This is an August library; use check, test, or package pack. Import its exports from an application with main.aug to run it.');
         if (command === 'format' || command === 'migrate') {
@@ -216,8 +344,17 @@ export async function main(argv) {
             }
             const results = [];
             const coverage = options.includes('--coverage'), reports = [];
+            const nativeInputs = backend === 'llvm' ? await prepareNativePackages(root, { offline: options.includes('--offline'), frozen: options.includes('--frozen') }) : undefined;
+            const toolchain = backend === 'llvm' ? await prepareLLVMCompiler(options.includes('--offline'), { root, frozen: options.includes('--frozen') }) : undefined;
             for (const [index, { unit, checked: testChecked }] of checks.entries()) {
-                const native = compileNative(root, generateC(testChecked, { coverage }), { testIndex: index, checked: testChecked });
+                let native;
+                if (backend === 'llvm')
+                    native = compileLLVM(testChecked, { testIndex: index, coverage, native: nativeInputs, toolchain });
+                else {
+                    const generated = generateC(testChecked, { coverage });
+                    await prepareNativeDependencies(generated, { offline: options.includes('--offline') });
+                    native = compileNative(root, generated, { testIndex: index, checked: testChecked });
+                }
                 const report = join(root, '.aug-build', 'tests', `coverage-${index}.tsv`);
                 reports.push(report);
                 if (coverage)
@@ -244,7 +381,7 @@ export async function main(argv) {
                 `${passed} passed, ${failed} failed\n` + (report ? `Coverage: ${report.covered}/${report.executable} statement lines (${report.percent.toFixed(1)}%); ${report.path}\n` : ''));
             return failed ? 1 : 0;
         }
-        const checked = checkProject(project);
+        let checked = checkProject(project);
         const testChecks = checkUnitTests(project, discovered.tests);
         checked.diagnostics = uniqueDiagnostics([...checked.diagnostics, ...discovered.diagnostics,
             ...testChecks.flatMap(entry => entry.checked.diagnostics)]);
@@ -305,15 +442,41 @@ export async function main(argv) {
             process.stdout.write(json ? JSON.stringify(result) + '\n' : result.stale.length ? 'Stale specifications:\n' + result.stale.map(file => '  ' + file).join('\n') + '\n' : `${result.files} specification artifact(s) ${options.includes('--check') ? 'are current' : 'generated'}.\n`);
             return result.stale.length ? 1 : 0;
         }
-        const generated = generateC(checked);
+        if (['build', 'run', 'bench'].includes(command) && !options.includes('--frozen')) {
+            checked = updateSpecHints(checked);
+            if (checked.diagnostics.some(issue => issue.severity !== 'warning')) {
+                printDiagnostics(checked.diagnostics, json, root);
+                return 1;
+            }
+        }
+        if (command === 'emit-llvm') {
+            process.stdout.write(generateLLVM(lowerToIR(checked)));
+            return 0;
+        }
+        if (command === 'emit-ir') {
+            process.stdout.write(JSON.stringify(lowerToIR(checked), null, 2) + '\n');
+            return 0;
+        }
+        if ((backend === 'c' || command === 'emit-c') && checked.native.resources.size + checked.native.functions.size)
+            throw new Error('NATIVE_BACKEND: Checked native packages require --backend llvm. The C reference backend cannot lower this native ABI.');
         if (command === 'emit-c') {
-            process.stdout.write(generated);
+            process.stdout.write(generateC(checked));
             return 0;
         }
         if (command === 'bench' && (!Number.isInteger(iterations) || iterations < 1 || iterations > 1000 ||
             !Number.isInteger(warmup) || warmup < 0 || warmup > 100 || !Number.isInteger(timeout) || timeout < 1))
             throw new Error('bench requires iterations 1–1000, warmup 0–100, and a positive timeout');
-        const native = compileNative(root, generated, { output: outputOption, release: command === 'bench' ? true : undefined, checked });
+        let native;
+        if (backend === 'llvm') {
+            const inputs = await prepareNativePackages(root, { offline: options.includes('--offline'), frozen: options.includes('--frozen') });
+            const toolchain = await prepareLLVMCompiler(options.includes('--offline'), { root, frozen: options.includes('--frozen') });
+            native = compileLLVM(checked, { output: outputOption, release: command === 'bench' || project.config.optimization === 'release', native: inputs, toolchain });
+        }
+        else {
+            const generated = generateC(checked);
+            await prepareNativeDependencies(generated, { offline: options.includes('--offline') });
+            native = compileNative(root, generated, { output: outputOption, release: command === 'bench' ? true : undefined, checked });
+        }
         const output = native.output;
         if (native.status !== 0) {
             if (native.diagnostics.length)
@@ -322,7 +485,8 @@ export async function main(argv) {
                 process.stderr.write(native.error + '\n');
             return native.status;
         }
-        updateSpecs(checked);
+        if (!options.includes('--frozen'))
+            updateSpecs(checked);
         if (command === 'build') {
             process.stdout.write(json ? JSON.stringify({ output, sourceMap: output + '.augmap.json' }) + '\n' : `${output}\n`);
             return 0;
@@ -334,11 +498,19 @@ export async function main(argv) {
         }
         const run = spawnSync(output, programArgs, { stdio: 'inherit', cwd: root });
         if (run.error)
-            throw run.error;
+            throw new Error(`Cannot start the compiled program ${output}: ${run.error.message}.\nCheck executable permissions and the native shared-library paths.`);
+        if (run.signal)
+            process.stderr.write(`Program stopped by ${run.signal}. Check the runtime message above; aug run compiled and started ${output}.\n`);
+        else if (run.status !== 0)
+            process.stderr.write(`Program exited with status ${run.status}.\n`);
         return run.status ?? 1;
     }
     catch (error) {
-        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
+        if (error instanceof BackendUnsupported || error instanceof IRVerificationError) {
+            printDiagnostics([{ ...error.span, code: error.code, message: error.message }], json, root);
+            return 1;
+        }
+        process.stderr.write(failureMessage(error) + '\n');
+        return error instanceof Error && 'exitCode' in error && typeof error.exitCode === 'number' ? error.exitCode : 1;
     }
 }

package/src/codegen.js

@@ -154,7 +154,7 @@ class CGenerator {
             `  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.checked.project.files.get(file)?.items.some(item => item.kind === 'function' && item.externC && item.name.startsWith('_aug_http_'))) ? [this.httpConfiguration()] : []),
             ...[...this.coverage.values()].map(point => `  aug_coverage_register(${cString(point.file)}, ${point.line});`),
             initializeBindings,
             `  AugValue result = aug_main_body(NULL, 0);`,
@@ -206,7 +206,8 @@ class CGenerator {
             `  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);'] : []),
+            `  if (aug_has_error) { aug_drop_partial(value); value = aug_scalar_null(); }`,
+            ...(cls.kind === 'class' && cls.record ? ['  if (!aug_has_error) aug_freeze(value);'] : []),
             `  aug_frame_leave(&frame);`,
             `  return value;`,
             `}`,
@@ -377,18 +378,25 @@ class BodyEmitter {
     locals = new Map();
     owned = new Set();
     classFields = new Map();
+    ownedClassFields = new Set();
     scalarSlots = new Set();
     slots = 1;
     labelCounter = 0;
     errorTarget = 'aug_cleanup';
     returnTarget = 'aug_cleanup';
     continuation;
+    constructionNext = false;
+    constructorResults = new Set();
     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));
+            fieldsOf(owner).forEach((field, index) => {
+                this.classFields.set(field.name, index);
+                if (field.ownership === 'own')
+                    this.ownedClassFields.add(field.name);
+            });
     }
     addParameter(name, index, owned = false) {
         const slot = this.newSlot();
@@ -398,6 +406,7 @@ class BodyEmitter {
             this.owned.add(slot);
     }
     initializeInterceptor(layer, params, name, method) {
+        this.constructionNext = layer.constructorResultFresh === true;
         const receiver = method ? this.newSlot() : undefined;
         if (receiver !== undefined)
             this.line(`${this.slot(receiver)} = self;`);
@@ -448,6 +457,8 @@ class BodyEmitter {
         const slot = this.newSlot();
         this.line(`${this.slot(slot)} = ${next.target}(${next.receiver === undefined ? '' :
             `${this.slot(next.receiver)}, `}${array}, ${args.length});`);
+        if (this.constructionNext)
+            this.constructorResults.add(slot);
         this.line(`if (aug_has_error) goto ${this.errorTarget};`);
         return slot;
     }
@@ -478,7 +489,8 @@ class BodyEmitter {
         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 values = expr.call.args.map(argument => argument.kind === 'formInput' ? undefined : this.emitExpr(argument));
+            const args = plan.parameters.map(parameter => parameter.form || parameter.source === undefined ? undefined : values[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});`);
@@ -513,7 +525,9 @@ class BodyEmitter {
             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});`);
+            const captures = this.label('task_owned');
+            this.line(`const unsigned char ${captures}[] = {${args.map((_, i) => this.generator.callPlan(call)?.ownerships?.[i] === 'own' ? '1' : '0').join(', ') || '0'}};`);
+            this.line(`${this.slot(slot)} = aug_task_start_owned(${name}, ${receiver === undefined ? 'aug_scalar_null()' : this.slot(receiver)}, ${array}, ${args.length}, ${captures});`);
             this.clearMovedArgs(call, (this.generator.callPlan(call)?.ownerships ?? []).map(ownership => ({ ownership: ownership ?? 'managed' })));
             this.line(`if (aug_has_error) goto ${this.errorTarget};`);
             return slot;
@@ -946,6 +960,8 @@ class BodyEmitter {
                 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 === 'name' && !this.locals.has(stmt.target.name))
+                targetOwns ||= this.ownedClassFields.has(stmt.target.name);
             if (stmt.target.kind === 'member') {
                 const memberName = stmt.target.name;
                 const node = this.generator.expressionType(stmt.target.object)?.def?.node;
@@ -1058,6 +1074,7 @@ class BodyEmitter {
     }
     emitTryAlways(stmt) {
         const outerError = this.errorTarget, outerReturn = this.returnTarget;
+        const ownedBefore = new Set(this.owned);
         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');
@@ -1070,8 +1087,11 @@ class BodyEmitter {
         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.line(`aug_scope_restore(${depth}); if (aug_cancelled) goto ${failed};`);
+        for (const slot of this.owned)
+            if (!ownedBefore.has(slot))
+                this.line(`aug_drop(${this.slot(slot)}); ${this.slot(slot)} = aug_scalar_null();`);
         this.errorTarget = failed;
         for (const clause of stmt.catches) {
             this.line(`if (aug_error_is(${cString(clause.type.name)})) {`);
@@ -1087,8 +1107,12 @@ class BodyEmitter {
         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(`aug_scope_restore(${depth});`);
+        for (const slot of this.owned)
+            if (!ownedBefore.has(slot))
+                this.line(`aug_drop(${this.slot(slot)}); ${this.slot(slot)} = aug_scalar_null();`);
+        this.line(`${this.slot(pending)} = aug_has_error ? aug_take_error() : aug_scalar_null();`);
         this.line(`${cancellation} = aug_cancelled; aug_cancelled = false;`);
         this.errorTarget = done;
         this.returnTarget = done;
@@ -1149,6 +1173,7 @@ class BodyEmitter {
             `  aug_lock_restore(aug_lock_base);`,
             `  aug_scope_join_to(aug_scope_base);`,
             ownedCleanup,
+            ...[...this.constructorResults].map(slot => `  aug_constructor_result_cleanup(${this.slot(slot)}, ${this.slot(0)});`),
             `  aug_scope_restore(aug_scope_base);`,
             `  AugValue result = ${this.slot(0)};`,
             `  aug_frame_leave(&frame);`,

package/src/compiler-packs.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { compilerVersion } from "./package-manager.js";
+import { ensureVerifiedArchive } from "./native-artifacts.js";
+import { nativeHostTarget } from "./native-contracts.js";
+import { withPackageLockAsync } from "./package-locking.js";
+import { readRuntimePack } from "./llvm-native.js";
+import { llvmPlatform } from "./llvm-platform.js";
+/** The CLI owns installation. Packages cannot choose or execute a compiler driver. */
+export async function prepareLLVMCompiler(offline = false, project) {
+    const compilerRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+    const platform = llvmPlatform();
+    if (process.env.AUG_LLVM_HOME) {
+        const tools = resolve(process.env.AUG_LLVM_HOME), runtime = resolve(process.env.AUG_RUNTIME_PACK ?? join(compilerRoot, '.aug-native/llvm/runtime'));
+        const version = spawnSync(join(tools, 'bin/llc'), ['--version'], { encoding: 'utf8' });
+        if (version.status !== 0 || !version.stdout.includes('LLVM version 23.1.2'))
+            throw new Error('LLVM_TOOLS: Contributor override requires LLVM 23.1.2');
+        readRuntimePack(runtime);
+        if (project?.frozen)
+            throw new Error('LLVM_LOCK: A frozen build requires the pinned compiler pack. Remove contributor toolchain overrides.');
+        return { tools, runtime, developmentOverride: true };
+    }
+    const file = join(compilerRoot, 'native/compiler-packs.json');
+    if (!existsSync(file))
+        throw new Error('LLVM_TOOLS: This compiler has no published LLVM tool manifest. Install the matching LLVM preview release.');
+    const manifest = JSON.parse(readFileSync(file, 'utf8'));
+    if (manifest.format !== 1 || manifest.compiler !== compilerVersion() || manifest.llvm !== '23.1.2' || !Array.isArray(manifest.packs))
+        throw new Error('LLVM_TOOLS: Invalid compiler-owned LLVM manifest');
+    const host = process.platform + '-' + process.arch, target = nativeHostTarget(), pack = manifest.packs.find(p => p.host === host && p.target === target.triple);
+    if (!pack)
+        throw new Error('NATIVE_TARGET: No compiler pack is published for ' + platform.host + '. Available compiler packs: ' + manifest.packs.map(p => p.host).join(', '));
+    if (pack.minimumOS !== platform.minimumOS || pack.minimumLibc !== platform.minimumLibc)
+        throw new Error('LLVM_TOOLS: Compiler manifest has a different platform baseline');
+    const prepare = async () => {
+        const lockFile = project ? join(project.root, 'aug.lock.json') : undefined, initial = lockFile && existsSync(lockFile) ? readFileSync(lockFile, 'utf8') : undefined;
+        const lock = initial ? JSON.parse(initial) : { format: 1, compiler: compilerVersion(), specifications: {}, roots: {}, packages: [], npm: {} };
+        if (lock.compiler !== compilerVersion())
+            throw new Error('LLVM_LOCK: Project lock belongs to another compiler. Run aug install.');
+        const previous = lock.native?.compilers?.[host];
+        if (project?.frozen && (!previous || previous.artifactSha256 !== pack.archive.sha256))
+            throw new Error('LLVM_LOCK: Frozen build has no matching compiler artifact for ' + host + '. Run aug build --backend llvm online once on this host.');
+        const directory = await ensureVerifiedArchive(pack.archive, { offline, executables: platform.tools.map(tool => 'bin/' + tool) });
+        const identity = JSON.parse(readFileSync(join(directory, 'compiler-pack.json'), 'utf8'));
+        if (identity.format !== 1 || identity.compiler !== manifest.compiler || identity.llvm !== manifest.llvm || identity.host !== host || identity.target !== target.triple)
+            throw new Error('LLVM_TOOLS: Verified archive has a different compiler/host/target identity');
+        const runtime = readRuntimePack(join(directory, 'runtime'));
+        if (identity.runtime !== runtime.sourceSha256)
+            throw new Error('LLVM_TOOLS: Compiler pack runtime identity differs from its runtime manifest');
+        const selection = { version: manifest.compiler, llvm: manifest.llvm, host, target: target.triple, artifactSha256: pack.archive.sha256, runtimeSha256: runtime.sourceSha256 };
+        if (project?.frozen && JSON.stringify(previous) !== JSON.stringify(selection))
+            throw new Error('LLVM_LOCK: Frozen compiler/runtime identity changed for ' + host);
+        if (lockFile && !project?.frozen) {
+            lock.native ??= { format: 1, targets: {} };
+            lock.native.compilers ??= {};
+            lock.native.compilers[host] = selection;
+            if ((existsSync(lockFile) ? readFileSync(lockFile, 'utf8') : undefined) !== initial)
+                throw new Error('LLVM_LOCK: Source lock changed during compiler installation; retry');
+            writeFileSync(lockFile + '.llvm.tmp', JSON.stringify(lock, null, 2) + '\n');
+            renameSync(lockFile + '.llvm.tmp', lockFile);
+        }
+        return { tools: directory, runtime: join(directory, 'runtime'), archiveSha256: pack.archive.sha256, developmentOverride: false };
+    };
+    return project ? withPackageLockAsync(join(project.root, '.aug-install.lock'), prepare) : prepare();
+}

package/src/config.js

@@ -55,7 +55,7 @@ export function loadConfig(root) {
             seen.add(path);
             if (path.startsWith('packages.')) {
                 if (!/^[a-z][a-z0-9_]*$/.test(entry[1]) || entry[1] === 'august' || !value)
-                    report(index + 1, 'Packages map lowercase public aliases to local paths or npm:name@exact-version');
+                    report(index + 1, 'Packages map lowercase public aliases to repository URLs, local paths, or npm:name@exact-version');
                 else
                     config.packages[entry[1]] = value;
                 continue;
@@ -101,7 +101,7 @@ export function loadConfig(root) {
             }
             continue;
         }
-        if (!entry || !(entry[1] in config || entry[1] === 'output')) {
+        if (!entry || !(entry[1] in config || ['output', 'backend'].includes(entry[1]))) {
             report(index + 1, `Unsupported configuration line ${JSON.stringify(raw)}`);
             continue;
         }
@@ -131,7 +131,7 @@ export function loadConfig(root) {
                 config[key] = Number(value);
         }
         else {
-            const choices = { optimization: ['debug', 'release'], assignment: ['equals', 'to'],
+            const choices = { backend: ['c', 'llvm'], optimization: ['debug', 'release'], assignment: ['equals', 'to'],
                 block_style: ['braces', 'indent'], indentation: ['spaces', 'tabs'] };
             if (!value || choices[key] && !choices[key].includes(value))
                 report(index + 1, `${key} needs ${choices[key]?.join(' or ') ?? 'a value'}`);

package/src/contracts.js

@@ -0,0 +1,10 @@
+import { schemaType } from "./schemas.js";
+import { tyName } from "./types.js";
+/** Checked contracts shared by the editor, documentation and wire schemas. */
+export function callableResult(checked, method) {
+    return checked.callableContracts.get(method)?.result ?? schemaType(checked.project, method.returns, method.span.file);
+}
+export function callableErrors(checked, method) {
+    return [...new Set([...(checked.callableContracts.get(method)?.errors.map(tyName) ?? method.throws.map(type => tyName(schemaType(checked.project, type, method.span.file)))),
+            ...(checked.interceptorPlans.get(method) ?? []).flatMap(layer => layer.errors.map(tyName))])].sort();
+}