@onda-lang/wasm-compiler 0.5.4 → 0.6.0

package/README.md

@@ -8,12 +8,12 @@ require LLVM, a Wasm linker, Rust, or `wasm-pack` after installation.
 import { createCompiler } from "@onda-lang/wasm-compiler";
 
 const compiler = await createCompiler();
-const artifact = await compiler.compileSource(source, {
+const { artifact, sourceFiles } = await compiler.compileSource(source, {
   sampleRate: 48_000,
   blockSize: 128,
 });
 
-console.log(artifact.wasm, artifact.metadata);
+console.log(artifact.wasm, artifact.metadata, sourceFiles);
 ```
 
 The package composes Onda's embedded Rust frontend with its Binaryen backend. The frontend emits
@@ -31,7 +31,7 @@ Project compilation resolves imports and includes entirely from the supplied sou
 embedded standard library:
 
 ```js
-const artifact = await compiler.compileProject({
+const { artifact, sourceFiles } = await compiler.compileProject({
   entry: "main.onda",
   sources: {
     "main.onda": mainSource,
@@ -41,10 +41,17 @@ const artifact = await compiler.compileProject({
   sampleRate: 48_000,
   blockSize: 128,
 });
+
+// Entry first, then transitive imports/includes. Embedded stdlib is excluded.
+console.log(sourceFiles);
 ```
 
 Compilation failures throw `OndaCompileError`. Its `diagnostics` property contains structured
-parse, semantic, MIR, configuration, or code-generation diagnostics.
+parse, semantic, MIR, configuration, or code-generation diagnostics. Its `sourceFiles` property
+contains every project source resolved before compilation stopped, allowing hosts to retain useful
+watch registrations while the project is temporarily invalid. `unresolvedSourceFiles` contains
+referenced non-standard-library candidates which were not present, allowing hosts to watch for their
+creation without treating them as contributing compilation inputs.
 
 ## Browser workers
 
@@ -52,7 +59,7 @@ Compilation is CPU-intensive. Use the built-in worker client in interactive brow
 
 ```js
 const compiler = await createCompiler({ worker: true });
-const artifact = await compiler.compileSource(source, options);
+const { artifact, sourceFiles } = await compiler.compileSource(source, options);
 await compiler.dispose();
 ```
 

package/bin/onda-wasm.js

@@ -72,7 +72,7 @@ export async function main(argv = process.argv.slice(2)) {
   const watOutput = parsed.watOut === undefined ? undefined : resolve(parsed.watOut);
   const compiler = await createCompiler();
   try {
-    const artifact = await compiler.compileProject({ entry, sources }, {
+    const { artifact } = await compiler.compileProject({ entry, sources }, {
       sampleRate: parsed.sampleRate,
       blockSize: parsed.blockSize,
       codegen: {

package/dist/backend/artifact.d.ts

@@ -3,6 +3,8 @@ export {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   createProcessorArtifactFiles,
   loadProcessorArtifactFiles,

package/dist/backend/constants.js

@@ -1,2 +1,2 @@
 // Synchronized from format-versions.json; do not edit this copy directly.
-export const SUPPORTED_MIR_SCHEMA_VERSION = 1;
+export const SUPPORTED_MIR_SCHEMA_VERSION = 3;

package/dist/backend/index.d.ts

@@ -4,6 +4,8 @@ export {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   createProcessorArtifactFiles,
   loadProcessorArtifactFiles,

package/dist/backend/index.js

@@ -8,6 +8,8 @@ import {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   validateProcessorMetadata,
 } from "./artifact.js";
@@ -17,6 +19,8 @@ export {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   createProcessorArtifactFiles,
   loadProcessorArtifactFiles,
@@ -38,6 +42,7 @@ const MAX_MEMORY_PAGES = 65_536;
 const WASM32_ADDRESS_SPACE_BYTES = MAX_MEMORY_PAGES * PAGE_BYTES;
 const DEFAULT_OPTIMIZE_LEVEL = 4;
 const ONDA_PROCESS_FULL_BLOCK = (1 << 0) | (1 << 1);
+const RUNTIME_FAILURE_GLOBAL = "$onda.runtime_failure";
 const MATH_KERNEL_INTRINSICS = new Set([
   "sin",
   "cos",
@@ -179,6 +184,7 @@ class MirCompiler {
       ? MATH_KERNEL_RESERVED_END
       : STATIC_BASE;
     this.internalHelpers = new Set();
+    this.functionMayFail = [];
     this.nextLabel = 0;
   }
 
@@ -297,6 +303,7 @@ class MirCompiler {
     this.validateCurrentSchemaEnvelope();
     this.validateProcessEntrySignature();
     this.validateAcyclicCallGraph();
+    this.analyzeRecoverableFailures();
   }
 
   validateCurrentSchemaEnvelope() {
@@ -444,6 +451,86 @@ class MirCompiler {
     }
   }
 
+  analyzeRecoverableFailures() {
+    const callees = this.mir.functions.map(() => new Set());
+    const direct = this.mir.functions.map(() => false);
+    const binaryMayFail = (functionId, value) => {
+      if (
+        value.kind !== "binary"
+        || !["divide", "remainder"].includes(value.data?.op)
+      ) {
+        return false;
+      }
+      const lhs = value.data.lhs;
+      const scalar = lhs.kind === "constant"
+        ? lhs.data.type
+        : this.requireScalarType(
+            this.mir.functions[functionId].locals[lhs.data].ty,
+            `binary operand in '${this.mir.functions[functionId].name}'`,
+          );
+      return scalar === "i32" || scalar === "i64";
+    };
+    const checkedBoundsKinds = new Set([
+      "array_window",
+      "buffer_load",
+      "buffer_param_load",
+      "buffer_param_store",
+      "buffer_store",
+      "const_data_load",
+      "index",
+      "input_load",
+      "make_slice",
+      "output_load",
+      "output_store",
+      "control_output_store",
+    ]);
+    const dynamicBoundsKinds = new Set([
+      "slice_element",
+      "slice_load",
+      "slice_store",
+      "slice_window",
+    ]);
+    const scan = (functionId, value) => {
+      if (value === null || value === undefined) return;
+      if (Array.isArray(value)) {
+        for (const entry of value) scan(functionId, entry);
+        return;
+      }
+      if (typeof value !== "object") return;
+      if (value.kind === "call" && Number.isInteger(value.data?.function)) {
+        callees[functionId].add(value.data.function);
+      }
+      const bounds = value.data?.bounds;
+      if (
+        value.kind === "process_frame"
+        || value.kind === "slice_copy"
+        || binaryMayFail(functionId, value)
+        || (checkedBoundsKinds.has(value.kind) && bounds === "checked")
+        || (dynamicBoundsKinds.has(value.kind) && bounds !== "unchecked")
+      ) {
+        direct[functionId] = true;
+      }
+      for (const child of Object.values(value)) scan(functionId, child);
+    };
+    for (const [functionId, func] of this.mir.functions.entries()) {
+      scan(functionId, func.body);
+    }
+    this.functionMayFail = [...direct];
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const [functionId, targets] of callees.entries()) {
+        if (
+          !this.functionMayFail[functionId]
+          && [...targets].some((target) => this.functionMayFail[target])
+        ) {
+          this.functionMayFail[functionId] = true;
+          changed = true;
+        }
+      }
+    }
+  }
+
   buildLayouts() {
     this.stateLayout = this.layoutNamedValues(this.mir.state);
     this.paramLayout = this.layoutNamedValues(this.mir.interface.params);
@@ -663,6 +750,12 @@ class MirCompiler {
     for (const name of Object.values(POINTER_GLOBALS)) {
       this.module.addGlobal(name, binaryen.i32, true, this.module.i32.const(0));
     }
+    this.module.addGlobal(
+      RUNTIME_FAILURE_GLOBAL,
+      binaryen.i32,
+      true,
+      this.module.i32.const(0),
+    );
   }
 
   addMathKernel() {
@@ -1049,6 +1142,62 @@ class MirCompiler {
     );
   }
 
+  defaultFunctionResult(context) {
+    const scalars = context.function.results.map((typeId, resultId) =>
+      this.requireScalarType(
+        typeId,
+        `result ${resultId} of '${context.function.name}'`,
+      ),
+    );
+    const values = scalars.map((scalar) => this.zero(scalar));
+    if (values.length === 0) return undefined;
+    if (values.length === 1) return values[0];
+    return this.module.tuple.make(values);
+  }
+
+  returnFromCurrentFunction(context) {
+    return this.module.return(this.defaultFunctionResult(context));
+  }
+
+  raiseRuntimeFailure(context) {
+    return this.module.block(null, [
+      this.module.global.set(
+        RUNTIME_FAILURE_GLOBAL,
+        this.module.i32.const(PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE),
+      ),
+      this.returnFromCurrentFunction(context),
+    ]);
+  }
+
+  propagateRuntimeFailure(calleeId, context) {
+    if (!this.functionMayFail[calleeId]) return [];
+    return [
+      this.module.if(
+        this.module.i32.ne(
+          this.module.global.get(RUNTIME_FAILURE_GLOBAL, binaryen.i32),
+          this.module.i32.const(PROCESSOR_EXECUTION_OK),
+        ),
+        this.returnFromCurrentFunction(context),
+      ),
+    ];
+  }
+
+  resetRuntimeFailure(functionId) {
+    if (!this.functionMayFail[functionId]) return [];
+    return [
+      this.module.global.set(
+        RUNTIME_FAILURE_GLOBAL,
+        this.module.i32.const(PROCESSOR_EXECUTION_OK),
+      ),
+    ];
+  }
+
+  executionStatus(functionId) {
+    return this.functionMayFail[functionId]
+      ? this.module.global.get(RUNTIME_FAILURE_GLOBAL, binaryen.i32)
+      : this.module.i32.const(PROCESSOR_EXECUTION_OK);
+  }
+
   addAbiWrappers() {
     const initId = this.mir.entry_points.init;
     const processId = this.mir.entry_points.process;
@@ -1062,6 +1211,7 @@ class MirCompiler {
         (this.options.simd ? binaryen.Features.SIMD128 : 0),
     );
     const initBody = this.module.block(null, [
+      ...this.resetRuntimeFailure(initId),
       this.module.global.set(
         POINTER_GLOBALS.params,
         this.module.local.get(0, binaryen.i32),
@@ -1076,11 +1226,12 @@ class MirCompiler {
         this.module.i32.const(this.stateLayout.byteLength ?? 0),
       ),
       this.module.call(this.functionNames[initId], [], binaryen.none),
-    ]);
+      this.executionStatus(initId),
+    ], binaryen.i32);
     this.module.addFunction(
       "$onda.abi.init",
       binaryen.createType([binaryen.i32, binaryen.i32]),
-      binaryen.none,
+      binaryen.i32,
       [],
       initBody,
     );
@@ -1121,7 +1272,13 @@ class MirCompiler {
       ),
     );
     const processBody = this.module.block(null, [
-      this.module.if(invalidRange, this.module.unreachable()),
+      this.module.if(
+        invalidRange,
+        this.module.return(
+          this.module.i32.const(PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE),
+        ),
+      ),
+      ...this.resetRuntimeFailure(processId),
       this.module.global.set(
         POINTER_GLOBALS.state,
         this.module.local.get(0, binaryen.i32),
@@ -1159,11 +1316,12 @@ class MirCompiler {
         [startFrame(), frames(), flags()],
         binaryen.none,
       ),
-    ]);
+      this.executionStatus(processId),
+    ], binaryen.i32);
     this.module.addFunction(
       "$onda.abi.process",
       processParams,
-      binaryen.none,
+      binaryen.i32,
       [],
       processBody,
     );
@@ -1182,6 +1340,7 @@ class MirCompiler {
       }
       const wrapperName = `$onda.abi.event.${eventId}`;
       const body = this.module.block(null, [
+        ...this.resetRuntimeFailure(event.handler),
         this.module.global.set(
           POINTER_GLOBALS.eventPayload,
           this.module.local.get(0, binaryen.i32),
@@ -1211,11 +1370,12 @@ class MirCompiler {
           this.module.local.get(6, binaryen.i32),
         ),
         this.module.call(this.functionNames[event.handler], [], binaryen.none),
-      ]);
+        this.executionStatus(event.handler),
+      ], binaryen.i32);
       this.module.addFunction(
         wrapperName,
         binaryen.createType(Array.from({ length: 7 }, () => binaryen.i32)),
-        binaryen.none,
+        binaryen.i32,
         [],
         body,
       );
@@ -1465,6 +1625,7 @@ class MirCompiler {
         this.module.local.set(resultSpill.index, call),
         ...afterCall,
         ...assignResults,
+        ...this.propagateRuntimeFailure(data.function, context),
       ]);
     }
     let compiledCall;
@@ -1492,8 +1653,18 @@ class MirCompiler {
         ),
       ]);
     }
-    if (localReferenceSync.length === 0) return compiledCall;
-    return this.module.block(null, [...beforeCall, compiledCall, ...afterCall]);
+    if (localReferenceSync.length === 0) {
+      const propagation = this.propagateRuntimeFailure(data.function, context);
+      return propagation.length === 0
+        ? compiledCall
+        : this.module.block(null, [compiledCall, ...propagation]);
+    }
+    return this.module.block(null, [
+      ...beforeCall,
+      compiledCall,
+      ...afterCall,
+      ...this.propagateRuntimeFailure(data.function, context),
+    ]);
   }
 
   compileOutputStore(data, context) {
@@ -1608,6 +1779,7 @@ class MirCompiler {
           scalar,
           () => this.compileValue(data.lhs, context),
           () => this.compileValue(data.rhs, context),
+          context,
         );
       }
       case "compare": {
@@ -1718,7 +1890,7 @@ class MirCompiler {
     const invalid = this.module.i32.ge_u(offset(), frames());
     return this.module.if(
       invalid,
-      this.module.unreachable(),
+      this.raiseRuntimeFailure(context),
       this.module.i32.add(startFrame(), offset()),
     );
   }
@@ -1816,6 +1988,7 @@ class MirCompiler {
       rawIndex,
       () => this.compileBufferParamTotalScalarLen(data.parameter, context),
       data.bounds,
+      context,
       true,
     );
     return this.module.i32.add(
@@ -1849,6 +2022,7 @@ class MirCompiler {
       rawIndex,
       () => this.compileBufferTotalScalarLen(data.buffer),
       data.bounds,
+      context,
       true,
     );
     const pointer = this.loadBufferTableValue(
@@ -2061,6 +2235,7 @@ class MirCompiler {
       () => this.compileValue(data.len, context),
       () => source()[1],
       data.bounds,
+      context,
     );
     return [
       this.module.i32.add(
@@ -2075,7 +2250,7 @@ class MirCompiler {
     ];
   }
 
-  compileSliceRange(start, len, sourceLen, bounds) {
+  compileSliceRange(start, len, sourceLen, bounds, context) {
     const zero = () => this.module.i32.const(0);
     if (bounds === "unchecked") {
       return { start, len };
@@ -2111,7 +2286,7 @@ class MirCompiler {
       };
       return { start: normalizedStart, len: normalizedLen };
     }
-    if (bounds === "trap") {
+    if (bounds === "checked") {
       const invalid = () => {
         const remaining = () => this.module.i32.sub(sourceLen(), start());
         return this.module.i32.or(
@@ -2127,7 +2302,7 @@ class MirCompiler {
       };
       return {
         start: () =>
-          this.module.if(invalid(), this.module.unreachable(), start()),
+          this.module.if(invalid(), this.raiseRuntimeFailure(context), start()),
         len,
       };
     }
@@ -2188,6 +2363,7 @@ class MirCompiler {
         () => this.compileValue(source.data.channel, context),
         channels,
         "clamp",
+        context,
         true,
       );
       return [
@@ -2221,6 +2397,7 @@ class MirCompiler {
         () => this.compileValue(source.data.channel, context),
         channels,
         "clamp",
+        context,
         true,
       );
       return [
@@ -2260,14 +2437,16 @@ class MirCompiler {
       () => this.compileSliceValue(slice, context),
       () => this.compileValue(index, context),
       bounds,
+      context,
     );
   }
 
-  compileSliceAddressWithFactories(slice, index, bounds) {
+  compileSliceAddressWithFactories(slice, index, bounds, context) {
     const bounded = this.compileDynamicBoundedIndex(
       index,
       () => slice()[1],
       bounds,
+      context,
     );
     return this.module.i32.add(
       slice()[0],
@@ -2295,6 +2474,7 @@ class MirCompiler {
           sourceType.data.len - parameterType.data.len,
         ),
       data.bounds,
+      context,
     );
     return this.module.i32.add(
       this.placeAddress(data.array, context),
@@ -2318,6 +2498,7 @@ class MirCompiler {
           this.module.i32.const(requiredLen),
         ),
       data.bounds,
+      context,
     );
     const address = () =>
       this.module.i32.add(
@@ -2340,12 +2521,12 @@ class MirCompiler {
       );
     return this.module.if(
       invalidShape(),
-      this.module.unreachable(),
+      this.raiseRuntimeFailure(context),
       address(),
     );
   }
 
-  compileWindowStart(start, maximum, bounds) {
+  compileWindowStart(start, maximum, bounds, context) {
     const zero = () => this.module.i32.const(0);
     if (bounds === "unchecked") {
       return start;
@@ -2365,14 +2546,14 @@ class MirCompiler {
         );
       };
     }
-    if (bounds === "trap") {
+    if (bounds === "checked") {
       return () =>
         this.module.if(
           this.module.i32.or(
             this.module.i32.lt_s(start(), zero()),
             this.module.i32.gt_s(start(), maximum()),
           ),
-          this.module.unreachable(),
+          this.raiseRuntimeFailure(context),
           start(),
         );
     }
@@ -2629,7 +2810,7 @@ class MirCompiler {
           source()[1],
         ),
       ),
-      this.module.if(invalidOverlap(), this.module.unreachable()),
+      this.module.if(invalidOverlap(), this.raiseRuntimeFailure(context)),
       this.module.local.set(counter, this.module.i32.const(0)),
       copy,
     ]);
@@ -2892,7 +3073,7 @@ class MirCompiler {
         ),
       );
     }
-    if (bounds === "trap") {
+    if (bounds === "checked") {
       const outOfBounds = this.module.i32.or(
         this.module.i32.lt_s(
           this.compileValue(value, context),
@@ -2905,14 +3086,20 @@ class MirCompiler {
       );
       return this.module.if(
         outOfBounds,
-        this.module.unreachable(),
+        this.raiseRuntimeFailure(context),
         this.compileValue(value, context),
       );
     }
     this.fail(`unknown bounds mode '${String(bounds)}'`);
   }
 
-  compileDynamicBoundedIndex(index, length, bounds, clampLengthKnownPositive = false) {
+  compileDynamicBoundedIndex(
+    index,
+    length,
+    bounds,
+    context,
+    clampLengthKnownPositive = false,
+  ) {
     if (bounds === "unchecked") {
       return index();
     }
@@ -2932,17 +3119,17 @@ class MirCompiler {
       if (clampLengthKnownPositive) return clamped();
       return this.module.if(
         this.module.i32.le_s(length(), this.module.i32.const(0)),
-        this.module.unreachable(),
+        this.raiseRuntimeFailure(context),
         clamped(),
       );
     }
-    if (bounds === "trap") {
+    if (bounds === "checked") {
       return this.module.if(
         this.module.i32.or(
           this.module.i32.lt_s(index(), this.module.i32.const(0)),
           this.module.i32.ge_s(index(), length()),
         ),
-        this.module.unreachable(),
+        this.raiseRuntimeFailure(context),
         index(),
       );
     }
@@ -2966,7 +3153,7 @@ class MirCompiler {
     }
   }
 
-  compileBinary(op, scalar, lhs, rhs) {
+  compileBinary(op, scalar, lhs, rhs, context) {
     if (!supportsMirOperation("binary", op, scalar)) {
       this.fail(`binary operation '${String(op)}' does not support scalar '${scalar}'`);
     }
@@ -2990,13 +3177,26 @@ class MirCompiler {
           wasm.eq(lhs(), minimum()),
           wasm.eq(rhs(), negativeOne()),
         );
-        return this.module.if(overflow, minimum(), wasm.div_s(lhs(), rhs()));
+        const division = this.module.if(
+          overflow,
+          minimum(),
+          wasm.div_s(lhs(), rhs()),
+        );
+        return this.module.if(
+          wasm.eq(rhs(), this.zero(scalar)),
+          this.raiseRuntimeFailure(context),
+          division,
+        );
       }
       case "remainder":
         if (!integer) {
           return this.compileMathKernelCall("remainder", scalar, [lhs(), rhs()]);
         }
-        return wasm.rem_s(lhs(), rhs());
+        return this.module.if(
+          wasm.eq(rhs(), this.zero(scalar)),
+          this.raiseRuntimeFailure(context),
+          wasm.rem_s(lhs(), rhs()),
+        );
       case "bit_and": return wasm.and(lhs(), rhs());
       case "bit_or": return wasm.or(lhs(), rhs());
       case "bit_xor": return wasm.xor(lhs(), rhs());
@@ -3083,6 +3283,16 @@ class MirCompiler {
           return this.module.select(wasm.lt_s(arg(0), arg(1)), arg(0), arg(1));
         case "max":
           return this.module.select(wasm.gt_s(arg(0), arg(1)), arg(0), arg(1));
+        case "range_clamp":
+          return this.module.select(
+            wasm.lt_s(arg(0), arg(1)),
+            arg(1),
+            this.module.select(
+              wasm.gt_s(arg(0), arg(2)),
+              arg(2),
+              arg(0),
+            ),
+          );
         default:
           this.fail(`intrinsic '${data.intrinsic}' requires f32 or f64 operands`);
       }
@@ -3096,6 +3306,22 @@ class MirCompiler {
       case "trunc": return wasm.trunc(args[0]);
       case "min": return wasm.min(args[0], args[1]);
       case "max": return wasm.max(args[0], args[1]);
+      case "range_clamp": {
+        const arg = (index) => this.compileValue(data.args[index], context);
+        return this.module.select(
+          wasm.ne(arg(0), arg(0)),
+          arg(1),
+          this.module.select(
+            wasm.lt(arg(0), arg(1)),
+            arg(1),
+            this.module.select(
+              wasm.gt(arg(0), arg(2)),
+              arg(2),
+              arg(0),
+            ),
+          ),
+        );
+      }
       case "fma": return this.compileMathKernelCall(data.intrinsic, scalar, args);
       case "sin":
       case "cos":
@@ -3418,6 +3644,7 @@ class MirCompiler {
           default_reprs: null,
           range_min_repr: null,
           range_max_repr: null,
+          param_control: null,
         })),
         params: this.mir.interface.params.map((param, id) => ({
           name: param.name,
@@ -3432,6 +3659,15 @@ class MirCompiler {
           default_reprs: this.constantReprs(param.default),
           range_min_repr: this.scalarRepr(param.range?.min),
           range_max_repr: this.scalarRepr(param.range?.max),
+          param_control: this.storageShape(param.ty).length === 1 && param.range
+            ? {
+                scale: param.control.scale,
+                curve: param.control.curve,
+                unit: param.control.unit,
+                step_repr: this.scalarRepr(param.control.step),
+                step_count: param.control.step_count,
+              }
+            : null,
         })),
         buffers: this.mir.interface.buffers.map((buffer) => {
           const channels = this.bufferChannelMetadata(buffer.channels);
@@ -3509,6 +3745,7 @@ class MirCompiler {
       default_reprs: null,
       range_min_repr: null,
       range_max_repr: null,
+      param_control: null,
     }));
   }
 

package/dist/build.json

@@ -1,12 +1,12 @@
 {
-  "ondaVersion": "0.5.4",
+  "ondaVersion": "0.6.0",
   "binaryenVersion": "130.0.0",
   "frontendPackage": "onda_compiler_web",
   "frontendOptimization": {
     "tool": "wasm-opt",
     "binaryenVersion": "130.0.0",
     "optimizeLevel": 4,
-    "inputBytes": 6441305,
-    "outputBytes": 4878025
+    "inputBytes": 6579319,
+    "outputBytes": 4975533
   }
 }

package/dist/frontend/README.md

@@ -15,12 +15,16 @@ The package build runs `wasm-pack --release` and then the workspace-pinned Binar
 optimizer so every local, CI, website, and npm build uses the same Binaryen release.
 
 The production exports `compile_to_mir_messagepack(source, sampleRate, blockSize)` and
-`compile_project_to_mir_messagepack(entryPath, sourcesJson, sampleRate, blockSize)` return compact
-schema-versioned bytes. JSON variants with the same names ending in `_json` remain available for
-inspection and tooling. Project compilation accepts a JSON object of project-relative paths to
-source strings, resolving imports and includes entirely in memory. Paths cannot escape the virtual
-project root. `mir_schema_version()` exposes the producer version for integration checks.
-Compilation failures reject with a JSON-encoded array of structured diagnostics.
+`compile_project_to_mir_messagepack(entryPath, sourcesJson, sampleRate, blockSize)` return a
+`FrontendMessagePackCompilation` containing compact schema-versioned bytes plus the ordered
+contributing project paths. JSON variants return the equivalent `FrontendJsonCompilation` for
+inspection and tooling. Both result types expose `take_mir()` and `source_files_json()`. Project
+compilation accepts a JSON object of project-relative paths to source strings, resolving imports and
+includes entirely in memory. Paths cannot escape the virtual project root. Embedded
+standard-library modules are omitted from the source manifest. `mir_schema_version()` exposes the
+producer version for integration checks. Compilation failures reject with a JSON-encoded object
+containing structured diagnostics, the partially resolved source list, and unresolved
+non-standard-library candidates which a host may watch for creation.
 
 The current producer and `packages/onda_binaryen_web` both use the current MIR schema. The browser playground
 under `examples/web/onda_wasm_playground` passes the generated MessagePack directly to the explicitly

package/dist/frontend/onda_compiler_web.d.ts

@@ -1,6 +1,22 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class FrontendJsonCompilation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    source_files_json(): string;
+    take_mir(): string;
+}
+
+export class FrontendMessagePackCompilation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    source_files_json(): string;
+    take_mir(): Uint8Array;
+}
+
 /**
  * Stateful `onda lsp` server for browser Worker transports.
  */
@@ -16,13 +32,13 @@ export class OndaLsp {
     set_analysis_options(sample_rate: number, block_size: number): void;
 }
 
-export function compile_project_to_mir_json(entry_path: string, sources_json: string, sample_rate: number, block_size: number): string;
+export function compile_project_to_mir_json(entry_path: string, sources_json: string, sample_rate: number, block_size: number): FrontendJsonCompilation;
 
-export function compile_project_to_mir_messagepack(entry_path: string, sources_json: string, sample_rate: number, block_size: number): Uint8Array;
+export function compile_project_to_mir_messagepack(entry_path: string, sources_json: string, sample_rate: number, block_size: number): FrontendMessagePackCompilation;
 
-export function compile_to_mir_json(source: string, sample_rate: number, block_size: number): string;
+export function compile_to_mir_json(source: string, sample_rate: number, block_size: number): FrontendJsonCompilation;
 
-export function compile_to_mir_messagepack(source: string, sample_rate: number, block_size: number): Uint8Array;
+export function compile_to_mir_messagepack(source: string, sample_rate: number, block_size: number): FrontendMessagePackCompilation;
 
 export function mir_schema_version(): number;
 
@@ -30,15 +46,21 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_frontendjsoncompilation_free: (a: number, b: number) => void;
+    readonly __wbg_frontendmessagepackcompilation_free: (a: number, b: number) => void;
     readonly __wbg_ondalsp_free: (a: number, b: number) => void;
-    readonly compile_project_to_mir_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
-    readonly compile_project_to_mir_messagepack: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
-    readonly compile_to_mir_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-    readonly compile_to_mir_messagepack: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly compile_project_to_mir_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly compile_project_to_mir_messagepack: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly compile_to_mir_json: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly compile_to_mir_messagepack: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly frontendjsoncompilation_source_files_json: (a: number) => [number, number];
+    readonly frontendjsoncompilation_take_mir: (a: number) => [number, number];
+    readonly frontendmessagepackcompilation_source_files_json: (a: number) => [number, number];
     readonly mir_schema_version: () => number;
     readonly ondalsp_handle_message: (a: number, b: number, c: number) => [number, number, number, number];
     readonly ondalsp_new: () => number;
     readonly ondalsp_set_analysis_options: (a: number, b: number, c: number) => [number, number];
+    readonly frontendmessagepackcompilation_take_mir: (a: number) => [number, number];
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/dist/frontend/onda_compiler_web.js

@@ -1,5 +1,101 @@
 /* @ts-self-types="./onda_compiler_web.d.ts" */
 
+export class FrontendJsonCompilation {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(FrontendJsonCompilation.prototype);
+        obj.__wbg_ptr = ptr;
+        FrontendJsonCompilationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FrontendJsonCompilationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_frontendjsoncompilation_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    source_files_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.frontendjsoncompilation_source_files_json(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    take_mir() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.frontendjsoncompilation_take_mir(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) FrontendJsonCompilation.prototype[Symbol.dispose] = FrontendJsonCompilation.prototype.free;
+
+export class FrontendMessagePackCompilation {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(FrontendMessagePackCompilation.prototype);
+        obj.__wbg_ptr = ptr;
+        FrontendMessagePackCompilationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FrontendMessagePackCompilationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_frontendmessagepackcompilation_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    source_files_json() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.frontendmessagepackcompilation_source_files_json(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    take_mir() {
+        const ret = wasm.frontendmessagepackcompilation_take_mir(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) FrontendMessagePackCompilation.prototype[Symbol.dispose] = FrontendMessagePackCompilation.prototype.free;
+
 /**
  * Stateful `onda lsp` server for browser Worker transports.
  */
@@ -64,29 +160,18 @@ if (Symbol.dispose) OndaLsp.prototype[Symbol.dispose] = OndaLsp.prototype.free;
  * @param {string} sources_json
  * @param {number} sample_rate
  * @param {number} block_size
- * @returns {string}
+ * @returns {FrontendJsonCompilation}
  */
 export function compile_project_to_mir_json(entry_path, sources_json, sample_rate, block_size) {
-    let deferred4_0;
-    let deferred4_1;
-    try {
-        const ptr0 = passStringToWasm0(entry_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(sources_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.compile_project_to_mir_json(ptr0, len0, ptr1, len1, sample_rate, block_size);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
-            ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
-    } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    const ptr0 = passStringToWasm0(entry_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(sources_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compile_project_to_mir_json(ptr0, len0, ptr1, len1, sample_rate, block_size);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return FrontendJsonCompilation.__wrap(ret[0]);
 }
 
 /**
@@ -94,7 +179,7 @@ export function compile_project_to_mir_json(entry_path, sources_json, sample_rat
  * @param {string} sources_json
  * @param {number} sample_rate
  * @param {number} block_size
- * @returns {Uint8Array}
+ * @returns {FrontendMessagePackCompilation}
  */
 export function compile_project_to_mir_messagepack(entry_path, sources_json, sample_rate, block_size) {
     const ptr0 = passStringToWasm0(entry_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -102,57 +187,42 @@ export function compile_project_to_mir_messagepack(entry_path, sources_json, sam
     const ptr1 = passStringToWasm0(sources_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     const ret = wasm.compile_project_to_mir_messagepack(ptr0, len0, ptr1, len1, sample_rate, block_size);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v3;
+    return FrontendMessagePackCompilation.__wrap(ret[0]);
 }
 
 /**
  * @param {string} source
  * @param {number} sample_rate
  * @param {number} block_size
- * @returns {string}
+ * @returns {FrontendJsonCompilation}
  */
 export function compile_to_mir_json(source, sample_rate, block_size) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.compile_to_mir_json(ptr0, len0, sample_rate, block_size);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compile_to_mir_json(ptr0, len0, sample_rate, block_size);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return FrontendJsonCompilation.__wrap(ret[0]);
 }
 
 /**
  * @param {string} source
  * @param {number} sample_rate
  * @param {number} block_size
- * @returns {Uint8Array}
+ * @returns {FrontendMessagePackCompilation}
  */
 export function compile_to_mir_messagepack(source, sample_rate, block_size) {
     const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.compile_to_mir_messagepack(ptr0, len0, sample_rate, block_size);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v2;
+    return FrontendMessagePackCompilation.__wrap(ret[0]);
 }
 
 /**
@@ -190,6 +260,12 @@ function __wbg_get_imports() {
     };
 }
 
+const FrontendJsonCompilationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_frontendjsoncompilation_free(ptr >>> 0, 1));
+const FrontendMessagePackCompilationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_frontendmessagepackcompilation_free(ptr >>> 0, 1));
 const OndaLspFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ondalsp_free(ptr >>> 0, 1));

package/dist/frontend/onda_compiler_web_bg.wasm.d.ts

@@ -1,15 +1,21 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_frontendjsoncompilation_free: (a: number, b: number) => void;
+export const __wbg_frontendmessagepackcompilation_free: (a: number, b: number) => void;
 export const __wbg_ondalsp_free: (a: number, b: number) => void;
-export const compile_project_to_mir_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
-export const compile_project_to_mir_messagepack: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
-export const compile_to_mir_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-export const compile_to_mir_messagepack: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const compile_project_to_mir_json: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const compile_project_to_mir_messagepack: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const compile_to_mir_json: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const compile_to_mir_messagepack: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const frontendjsoncompilation_source_files_json: (a: number) => [number, number];
+export const frontendjsoncompilation_take_mir: (a: number) => [number, number];
+export const frontendmessagepackcompilation_source_files_json: (a: number) => [number, number];
 export const mir_schema_version: () => number;
 export const ondalsp_handle_message: (a: number, b: number, c: number) => [number, number, number, number];
 export const ondalsp_new: () => number;
 export const ondalsp_set_analysis_options: (a: number, b: number, c: number) => [number, number];
+export const frontendmessagepackcompilation_take_mir: (a: number) => [number, number];
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

package/dist/frontend/package.json

@@ -5,7 +5,7 @@
     "onda contributors"
   ],
   "description": "Browser-safe Onda source-to-MIR compiler",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/dist/version.js

@@ -1 +1 @@
-export const ONDA_VERSION = "0.5.4";
+export const ONDA_VERSION = "0.6.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onda-lang/wasm-compiler",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "type": "module",
   "description": "Onda source-to-WebAssembly compiler for browsers and Node.js",
   "license": "MIT",
@@ -59,7 +59,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@onda-lang/processor-abi": "0.5.4",
+    "@onda-lang/processor-abi": "0.6.0",
     "binaryen": "130.0.0"
   },
   "publishConfig": {

package/src/index.d.ts

@@ -5,6 +5,8 @@ export {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   createProcessorArtifactFiles,
   loadProcessorArtifactFiles,
@@ -53,15 +55,21 @@ export interface OndaProject {
   sources: Record<string, string>;
 }
 
+export interface OndaCompilationResult {
+  artifact: OndaProcessorArtifact;
+  /** Entry first, then transitive non-stdlib imports/includes in discovery order. */
+  sourceFiles: string[];
+}
+
 export interface OndaCompilerInstance {
   compileSource(
     source: string,
     options?: OndaCompileOptions,
-  ): Promise<OndaProcessorArtifact>;
+  ): Promise<OndaCompilationResult>;
   compileProject(
     project: OndaProject,
     options?: OndaCompileOptions,
-  ): Promise<OndaProcessorArtifact>;
+  ): Promise<OndaCompilationResult>;
   sendLspMessage(message: OndaLspMessage): Promise<OndaLspMessage[]>;
   setLspAnalysisOptions(options?: OndaCompileOptions): Promise<void>;
   dispose(): Promise<void>;
@@ -108,6 +116,9 @@ export class OndaCompilerError extends Error {
 
 export class OndaCompileError extends OndaCompilerError {
   readonly diagnostics: OndaCompilerDiagnostic[];
+  readonly sourceFiles: string[];
+  /** Referenced non-stdlib source candidates which were not present. */
+  readonly unresolvedSourceFiles: string[];
 }
 
 export class OndaBinaryenError extends Error {}

package/src/index.js

@@ -3,6 +3,8 @@ import {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   createProcessorArtifactFiles,
   loadProcessorArtifactFiles,
@@ -27,6 +29,8 @@ export {
   PROCESSOR_ABI_VERSION,
   PROCESSOR_ARTIFACT_FORMAT,
   PROCESSOR_ARTIFACT_FORMAT_VERSION,
+  PROCESSOR_EXECUTION_OK,
+  PROCESSOR_EXECUTION_RUNTIME_SAFETY_FAILURE,
   PROCESSOR_SNAPSHOT_FORMAT_VERSION,
   createProcessorArtifactFiles,
   loadProcessorArtifactFiles,
@@ -46,7 +50,10 @@ export class OndaCompilerError extends Error {
 }
 
 export class OndaCompileError extends OndaCompilerError {
-  constructor(diagnostics, { cause } = {}) {
+  constructor(
+    diagnostics,
+    { cause, sourceFiles = [], unresolvedSourceFiles = [] } = {},
+  ) {
     const normalized = normalizeDiagnostics(diagnostics);
     const first = normalized[0];
     const message = first
@@ -55,6 +62,8 @@ export class OndaCompileError extends OndaCompilerError {
     super(message, { cause });
     this.name = "OndaCompileError";
     this.diagnostics = normalized;
+    this.sourceFiles = normalizeSourceFiles(sourceFiles);
+    this.unresolvedSourceFiles = normalizeSourceFiles(unresolvedSourceFiles);
   }
 }
 
@@ -72,9 +81,9 @@ class OndaCompiler {
       throw configurationError("source must be a string");
     }
     const compile = normalizeCompileOptions(options);
-    let mir;
+    let frontendCompilation;
     try {
-      mir = this.frontend.compile_to_mir_messagepack(
+      frontendCompilation = this.frontend.compile_to_mir_messagepack(
         source,
         compile.sampleRate,
         compile.blockSize,
@@ -82,7 +91,14 @@ class OndaCompiler {
     } catch (error) {
       throw diagnosticsFromFrontend(error);
     }
-    return compileMirTransport(mir, compile.codegen, this.compileTrustedMir);
+    const { mir, sourceFiles } = consumeFrontendCompilation(frontendCompilation);
+    const artifact = compileMirTransport(
+      mir,
+      compile.codegen,
+      this.compileTrustedMir,
+      sourceFiles,
+    );
+    return { artifact, sourceFiles };
   }
 
   async compileProject(project, options = {}) {
@@ -102,9 +118,9 @@ class OndaCompiler {
     }
 
     const compile = normalizeCompileOptions(options);
-    let mir;
+    let frontendCompilation;
     try {
-      mir = this.frontend.compile_project_to_mir_messagepack(
+      frontendCompilation = this.frontend.compile_project_to_mir_messagepack(
         project.entry,
         JSON.stringify(project.sources),
         compile.sampleRate,
@@ -113,7 +129,14 @@ class OndaCompiler {
     } catch (error) {
       throw diagnosticsFromFrontend(error);
     }
-    return compileMirTransport(mir, compile.codegen, this.compileTrustedMir);
+    const { mir, sourceFiles } = consumeFrontendCompilation(frontendCompilation);
+    const artifact = compileMirTransport(
+      mir,
+      compile.codegen,
+      this.compileTrustedMir,
+      sourceFiles,
+    );
+    return { artifact, sourceFiles };
   }
 
   async sendLspMessage(message) {
@@ -212,7 +235,10 @@ class WorkerOndaCompiler {
       return;
     }
     const error = message.error?.diagnostics
-      ? new OndaCompileError(message.error.diagnostics)
+      ? new OndaCompileError(message.error.diagnostics, {
+        sourceFiles: message.error.sourceFiles,
+        unresolvedSourceFiles: message.error.unresolvedSourceFiles,
+      })
       : new OndaCompilerError(message.error?.message ?? "compiler worker failed");
     if (message.error?.name) error.name = message.error.name;
     if (message.error?.stack) error.stack = message.error.stack;
@@ -310,7 +336,17 @@ function normalizeCompileOptions(options) {
   return { sampleRate, blockSize, codegen: options.codegen ?? {} };
 }
 
-function compileMirTransport(mir, codegen, compileTrustedMir) {
+function consumeFrontendCompilation(compilation) {
+  try {
+    const mir = compilation.take_mir();
+    const sourceFiles = normalizeSourceFiles(JSON.parse(compilation.source_files_json()));
+    return { mir, sourceFiles };
+  } finally {
+    compilation.free();
+  }
+}
+
+function compileMirTransport(mir, codegen, compileTrustedMir, sourceFiles) {
   try {
     return compileTrustedMir(mir, codegen);
   } catch (cause) {
@@ -325,7 +361,7 @@ function compileMirTransport(mir, codegen, compileTrustedMir) {
       end_line: 0,
       end_column: 0,
       trace: [],
-    }], { cause });
+    }], { cause, sourceFiles });
   }
 }
 
@@ -333,9 +369,16 @@ function diagnosticsFromFrontend(error) {
   const encoded = typeof error === "string" ? error : error?.message;
   if (typeof encoded === "string") {
     try {
-      const diagnostics = JSON.parse(encoded);
-      if (Array.isArray(diagnostics)) {
-        return new OndaCompileError(diagnostics, { cause: error });
+      const failure = JSON.parse(encoded);
+      if (Array.isArray(failure)) {
+        return new OndaCompileError(failure, { cause: error });
+      }
+      if (failure && Array.isArray(failure.diagnostics)) {
+        return new OndaCompileError(failure.diagnostics, {
+          cause: error,
+          sourceFiles: failure.source_files,
+          unresolvedSourceFiles: failure.unresolved_source_files,
+        });
       }
     } catch {}
   }
@@ -382,3 +425,8 @@ function normalizeDiagnostics(diagnostics) {
       : [],
   }));
 }
+
+function normalizeSourceFiles(sourceFiles) {
+  if (!Array.isArray(sourceFiles)) return [];
+  return sourceFiles.map((path) => String(path));
+}

package/src/worker.js

@@ -12,19 +12,19 @@ globalThis.addEventListener("message", async (event) => {
       return;
     }
     if (message.type === "compileSource") {
-      const artifact = await (await compiler()).compileSource(
+      const result = await (await compiler()).compileSource(
         message.source,
         message.options,
       );
-      respond(requestId, artifact, [artifact.wasm.buffer]);
+      respond(requestId, result, [result.artifact.wasm.buffer]);
       return;
     }
     if (message.type === "compileProject") {
-      const artifact = await (await compiler()).compileProject(
+      const result = await (await compiler()).compileProject(
         message.project,
         message.options,
       );
-      respond(requestId, artifact, [artifact.wasm.buffer]);
+      respond(requestId, result, [result.artifact.wasm.buffer]);
       return;
     }
     if (message.type === "lspMessage") {
@@ -53,6 +53,8 @@ globalThis.addEventListener("message", async (event) => {
         message: error?.message ?? String(error),
         stack: error?.stack,
         diagnostics: error?.diagnostics,
+        sourceFiles: error?.sourceFiles,
+        unresolvedSourceFiles: error?.unresolvedSourceFiles,
       },
     });
   }