@opendaw/studio-core-wasm 0.0.2

package/dist/WasmEngine.d.ts

@@ -0,0 +1,14 @@
+export type WasmEngineUrls = {
+    processorUrl: string;
+    offlineWorkerUrl: string;
+    wasmUrl: string;
+};
+export declare namespace WasmEngine {
+    const isEnabled: () => boolean;
+    const setEnabled: (enabled: boolean) => void;
+    const isReady: () => boolean;
+    const useForExports: () => boolean;
+    const ensureReady: (context: BaseAudioContext) => Promise<boolean>;
+    const install: (urls: WasmEngineUrls) => void;
+}
+//# sourceMappingURL=WasmEngine.d.ts.map

package/dist/WasmEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WasmEngine.d.ts","sourceRoot":"","sources":["../src/WasmEngine.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,cAAc,GAAG;IAEzB,YAAY,EAAE,MAAM,CAAA;IAEpB,gBAAgB,EAAE,MAAM,CAAA;IAExB,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,yBAAiB,UAAU,CAAC;IAKjB,MAAM,SAAS,QAAO,OAAqD,CAAA;IAE3E,MAAM,UAAU,GAAI,SAAS,OAAO,KAAG,IAAuD,CAAA;IAG9F,MAAM,OAAO,QAAO,OAA6B,CAAA;IAIjD,MAAM,aAAa,QAAO,OAAyE,CAAA;IAInG,MAAM,WAAW,GAAU,SAAS,gBAAgB,KAAG,OAAO,CAAC,OAAO,CAa5E,CAAA;IAEM,MAAM,OAAO,GAAI,MAAM,cAAc,KAAG,IAsB9C,CAAA;CAqFJ"}

package/dist/WasmEngine.js

@@ -0,0 +1,152 @@
+// Main-thread API of the WASM engine: `install` takes the host-served URLs (the prebuilt worklet module,
+// the prebuilt offline render worker, and the base serving the wasm binaries — all shipped in this
+// package's dist), registers the EngineVariant provider the studio-core EngineWorklet consults at
+// construction, and wires the offline render variant. `ensureReady` compiles the modules + registers the
+// processor module once. The WASM engine is the DEFAULT; localStorage only records an explicit opt-out.
+// Every engine (re)boot re-reads it, so the existing restart machinery swaps engines without a page reload.
+import { isNull, MutableObservableOption } from "@opendaw/lib-std";
+import { Communicator, Promises } from "@opendaw/lib-runtime";
+import { SyncSource } from "@opendaw/lib-box";
+import { EngineVariant, OfflineEngineRenderer } from "@opendaw/studio-core";
+import { createEngineMemory, loadEngineModules } from "./engine-modules";
+import { serializeUpdateTasks } from "./sync/serialize-update-tasks";
+import { createSyncLoopback } from "./sync/loopback";
+import { WASM_ENGINE_PROCESSOR_NAME, WASM_FROZEN_CHANNEL, WASM_SYNC_CHANNEL } from "./protocol";
+export var WasmEngine;
+(function (WasmEngine) {
+    const FLAG_KEY = "opendaw-wasm-engine";
+    const modules = new MutableObservableOption();
+    const config = new MutableObservableOption();
+    WasmEngine.isEnabled = () => localStorage.getItem(FLAG_KEY) !== "false";
+    WasmEngine.setEnabled = (enabled) => localStorage.setItem(FLAG_KEY, String(enabled));
+    // Whether the wasm modules are compiled and the processor is registered (i.e. `ensureReady` succeeded).
+    WasmEngine.isReady = () => modules.nonEmpty();
+    // Whether an offline render (mixdown, stems, publish, video audio) should run through the wasm variant:
+    // the engine is enabled, its artifacts actually loaded, and the offline worker is installed.
+    WasmEngine.useForExports = () => WasmEngine.isEnabled() && WasmEngine.isReady() && OfflineEngineRenderer.hasVariant();
+    // Compile the wasm modules + register the processor module (both once). Returns false when the engine
+    // artifacts are unavailable (e.g. a deploy without them), so callers can revert to the TS engine.
+    WasmEngine.ensureReady = async (context) => {
+        if (modules.nonEmpty()) {
+            return true;
+        }
+        const { processorUrl, wasmUrl } = config.unwrap("WasmEngine.install must run before ensureReady");
+        const { status, value, error } = await Promises.tryCatch((async () => {
+            await context.audioWorklet.addModule(processorUrl);
+            return loadEngineModules(wasmUrl);
+        })());
+        if (status === "rejected") {
+            console.warn("WASM engine unavailable:", error);
+            return false;
+        }
+        modules.wrap(value);
+        return true;
+    };
+    WasmEngine.install = (urls) => {
+        config.wrap(urls);
+        // The OFFLINE render path (mixdown/stems/freeze/benchmarks): the worker self-loads the wasm
+        // artifacts from `wasmUrl`, so no preloading is needed here.
+        OfflineEngineRenderer.installVariant(urls.offlineWorkerUrl, { wasmUrl: urls.wasmUrl });
+        OfflineEngineRenderer.installVariantPolicy(() => WasmEngine.useForExports()); // freeze/consolidation follow the toggle
+        EngineVariant.install(() => {
+            if (!WasmEngine.isEnabled() || modules.isEmpty()) {
+                return null;
+            }
+            const { engineModule, deviceModules, deviceBoxTypes, composites } = modules.unwrap();
+            const attachment = {
+                // A FRESH shared memory per boot: re-instantiating the engine re-applies its data segments,
+                // but a recycled heap would leak every allocation of the previous engine instance.
+                engineModule, deviceModules, deviceBoxTypes, composites, memory: createEngineMemory()
+            };
+            return {
+                processorName: WASM_ENGINE_PROCESSOR_NAME,
+                attachment,
+                connectSync: (messenger, project) => connectSync(messenger, project),
+                connectFrozenAudio: (messenger) => connectFrozenAudio(messenger, attachment.memory)
+            };
+        });
+    };
+    // Freeze PCM delivery: the worklet only ALLOCATES (a small RPC returning the engine's planar stereo
+    // pointer) and ATTACHES — the bulk copy runs here on the MAIN thread, straight into the shared engine
+    // memory. Operations chain sequentially: a second freeze reallocates `frozen_pending`, so no write may
+    // start while another is between allocate and attach (the engine reboot replay sends several at once).
+    // The worklet may memory.grow inside `frozen_allocate`, which leaves previously obtained buffer
+    // references stale (they keep their pre-grow length), so the buffer is re-read after the RPC returns.
+    const connectFrozenAudio = (messenger, memory) => {
+        const sender = Communicator.sender(messenger.channel(WASM_FROZEN_CHANNEL), dispatcher => new class {
+            frozenAllocate(frameCount, channels) {
+                return dispatcher.dispatchAndReturn(this.frozenAllocate, frameCount, channels);
+            }
+            frozenAttach(uuid, frameCount, channels, sampleRate) {
+                dispatcher.dispatchAndForget(this.frozenAttach, uuid, frameCount, channels, sampleRate);
+            }
+            frozenClear(uuid) { dispatcher.dispatchAndForget(this.frozenClear, uuid); }
+        });
+        const queue = { tail: Promise.resolve() };
+        return (uuid, audioData) => {
+            queue.tail = queue.tail.then(() => {
+                if (isNull(audioData)) {
+                    sender.frozenClear(uuid);
+                    return;
+                }
+                const { frames, numberOfFrames, numberOfChannels, sampleRate } = audioData;
+                const channels = Math.min(numberOfChannels, 2);
+                return sender.frozenAllocate(numberOfFrames, channels).then(pointer => {
+                    if (pointer === 0) {
+                        return;
+                    }
+                    const buffer = memory.buffer;
+                    for (let channel = 0; channel < channels; channel++) {
+                        new Float32Array(buffer, pointer + channel * numberOfFrames * Float32Array.BYTES_PER_ELEMENT, numberOfFrames)
+                            .set(frames[channel]);
+                    }
+                    sender.frozenAttach(uuid, numberOfFrames, channels, sampleRate);
+                });
+            }).catch(reason => console.warn("frozen audio delivery failed:", reason));
+        };
+    };
+    // SyncSource (unchanged) -> SYNCHRONOUS loopback -> serialize at emission time (the source graph's
+    // schema AND state — a MessageChannel hop would let a later transaction delete boxes before the batch
+    // resolves its primitive codecs) -> transaction bytes to the worklet's apply_updates. The `true` flag
+    // makes SyncSource open with a full dump of the graph, which is how the engine receives the project.
+    // A throttled checksum round-trip follows the batches on the same ordered channel: the worklet compares
+    // the source checksum against the engine's rolling checksum and escalates a divergence.
+    const CHECKSUM_INTERVAL_MS = 1_000;
+    const connectSync = (messenger, project) => {
+        const sender = Communicator.sender(messenger.channel(WASM_SYNC_CHANNEL), dispatcher => new class {
+            applyUpdates(bytes) {
+                dispatcher.dispatchAndForget(this.applyUpdates, Communicator.makeTransferable(bytes));
+            }
+            checksum(bytes) {
+                return dispatcher.dispatchAndReturn(this.checksum, bytes);
+            }
+        });
+        const throttle = { next: 0 };
+        const verifyChecksum = () => {
+            const now = performance.now();
+            if (now < throttle.next) {
+                return;
+            }
+            throttle.next = now + CHECKSUM_INTERVAL_MS;
+            sender.checksum(project.boxGraph.checksum())
+                .catch(reason => console.warn("wasm engine checksum verification failed:", reason));
+        };
+        const target = {
+            sendUpdates: (tasks) => {
+                sender.applyUpdates(serializeUpdateTasks(tasks, project.boxGraph));
+                verifyChecksum();
+            },
+            checksum: (value) => sender.checksum(value)
+        };
+        const loopback = createSyncLoopback();
+        const executor = Communicator.executor(loopback.target, target);
+        const syncSource = new SyncSource(project.boxGraph, loopback.source, true);
+        return {
+            terminate: () => {
+                syncSource.terminate();
+                executor.terminate();
+                loopback.terminate();
+            }
+        };
+    };
+})(WasmEngine || (WasmEngine = {}));

package/dist/boot.d.ts

@@ -0,0 +1,14 @@
+import { Procedure } from "@opendaw/lib-std";
+import { EngineToClient } from "@opendaw/studio-adapters";
+import { EngineExports } from "./engine-exports";
+import { CompositeSpec } from "./engine-modules";
+export type WasmEngineModules = {
+    engineModule: WebAssembly.Module;
+    deviceModules: ReadonlyArray<WebAssembly.Module>;
+    deviceBoxTypes: ReadonlyArray<string>;
+    composites: ReadonlyArray<CompositeSpec>;
+};
+export declare const describeEngineTrap: (engine: EngineExports, memory: WebAssembly.Memory, error: unknown) => unknown;
+export declare const instantiateWasmEngine: (modules: WasmEngineModules, memory: WebAssembly.Memory, sampleRate: number, engineToClient: EngineToClient) => EngineExports;
+export declare const drainResourceRequests: (engine: EngineExports, memory: WebAssembly.Memory, engineToClient: EngineToClient, pending: Set<Promise<unknown>>, fallbackSampleRate: number, onError: Procedure<unknown>) => void;
+//# sourceMappingURL=boot.d.ts.map

package/dist/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../src/boot.ts"],"names":[],"mappings":"AAGA,OAAO,EAAY,SAAS,EAA2B,MAAM,kBAAkB,CAAA;AAC/E,OAAO,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAC,aAAa,EAAmB,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAA;AAQ9C,MAAM,MAAM,iBAAiB,GAAG;IAC5B,YAAY,EAAE,WAAW,CAAC,MAAM,CAAA;IAChC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;IAChD,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;CAC3C,CAAA;AAKD,eAAO,MAAM,kBAAkB,GAAI,QAAQ,aAAa,EAAE,QAAQ,WAAW,CAAC,MAAM,EAAE,OAAO,OAAO,KAAG,OAItG,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,iBAAiB,EAAE,QAAQ,WAAW,CAAC,MAAM,EACtD,YAAY,MAAM,EAAE,gBAAgB,cAAc,KAAG,aAe1F,CAAA;AAOD,eAAO,MAAM,qBAAqB,GAAI,QAAQ,aAAa,EAAE,QAAQ,WAAW,CAAC,MAAM,EACjD,gBAAgB,cAAc,EAAE,SAAS,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAC9D,oBAAoB,MAAM,EAAE,SAAS,SAAS,CAAC,OAAO,CAAC,KAAG,IA4C/F,CAAA"}

package/dist/boot.js

@@ -0,0 +1,91 @@
+// Shared WASM-engine boot + resource plumbing for BOTH studio hosts: the realtime worklet processor and
+// the offline render worker. Links the engine + device side-modules (with the script/NAM bridges) and
+// runs the sample/soundfont load handshakes over the UNCHANGED EngineToClient RPC.
+import { isDefined, tryCatch } from "@opendaw/lib-std";
+import { readPanicMessage } from "./engine-exports";
+import { linkDevice, registerComposite } from "./device-linker";
+import { ScriptBridges } from "./script-bridge";
+import { NamBridges } from "./nam-bridge";
+import { simplifySoundfont } from "./soundfont-simplify";
+const ENGINE_TABLE_RESERVE = 512; // shared table slots reserved for the engine's own functions (it needs ~42)
+// A wasm trap surfaces as an anonymous "RuntimeError: unreachable" (panic=abort strips the message);
+// the engine's panic handler deposits the real message + location into a static buffer first, so attach
+// it before the error leaves the host.
+export const describeEngineTrap = (engine, memory, error) => {
+    const message = tryCatch(() => readPanicMessage(engine, memory));
+    if (message.status === "failure" || message.value.length === 0) {
+        return error;
+    }
+    return new Error(`wasm panic: ${message.value}`, { cause: error });
+};
+export const instantiateWasmEngine = (modules, memory, sampleRate, engineToClient) => {
+    const table = new WebAssembly.Table({ initial: ENGINE_TABLE_RESERVE, element: "anyfunc" });
+    const now = isDefined(globalThis.performance)
+        ? () => performance.now() * 1000.0 : () => Date.now() * 1000.0;
+    const engine = new WebAssembly.Instance(modules.engineModule, { env: { memory, __indirect_function_table: table, host_perf_now: now } }).exports;
+    engine.init(sampleRate);
+    const scriptBridges = new ScriptBridges(memory, engine, sampleRate, (uuid, message) => engineToClient.deviceMessage(uuid, message));
+    const namBridges = new NamBridges(memory, () => engineToClient.fetchNamWasm(), sampleRate);
+    const bridgeImports = { ...scriptBridges.imports(), ...namBridges.imports() };
+    modules.deviceModules.forEach((deviceModule, index) => linkDevice(engine, memory, table, deviceModule, modules.deviceBoxTypes[index], sampleRate, bridgeImports));
+    modules.composites.forEach(composite => registerComposite(engine, memory, composite));
+    return engine;
+};
+// Pop every sample/soundfont the engine queued and run the load handshake for each: fetch + decode over
+// the EngineToClient RPC, write into the engine allocation, mark ready. Each runs as its own async chain
+// tracked in `pending` (queryLoadingComplete awaits them); a failed sample resolves as 1-frame silence.
+// A throw INSIDE a continuation (an engine trap while writing the allocation) would otherwise vanish as
+// an unhandled rejection in the host's global scope, so it routes into `onError`.
+export const drainResourceRequests = (engine, memory, engineToClient, pending, fallbackSampleRate, onError) => {
+    const track = (promise) => {
+        const guarded = promise.catch(onError);
+        pending.add(guarded);
+        guarded.finally(() => pending.delete(guarded));
+    };
+    for (;;) {
+        const outPtr = engine.input_reserve(16);
+        const handle = engine.sample_take_request(outPtr);
+        if (handle < 0) {
+            break;
+        }
+        const uuid = new Uint8Array(memory.buffer, outPtr, 16).slice();
+        track(engineToClient.fetchAudio(uuid).then(data => {
+            const { numberOfFrames, numberOfChannels, sampleRate: dataRate, frames } = data;
+            const bytesPerChannel = numberOfFrames * Float32Array.BYTES_PER_ELEMENT;
+            const pointer = engine.sample_allocate(handle, numberOfChannels * bytesPerChannel);
+            // A dead handle (its slot was freed + generation-bumped between the request and this async
+            // delivery — e.g. the AudioFileBox delete/recreate churn when a recorded take is finalized)
+            // returns 0. Writing the frames at address 0 would corrupt the engine's own memory, so skip:
+            // the engine re-requests against the fresh handle when the new box syncs.
+            if (pointer === 0) {
+                return;
+            }
+            for (let channel = 0; channel < numberOfChannels; channel++) {
+                new Float32Array(memory.buffer, pointer + channel * bytesPerChannel, numberOfFrames)
+                    .set(frames[channel]);
+            }
+            engine.sample_set_ready(handle, numberOfFrames, numberOfChannels, dataRate);
+        }, (reason) => {
+            engine.sample_allocate(handle, 4);
+            engine.sample_set_ready(handle, 1, 1, fallbackSampleRate);
+            engineToClient.log(`sample load failed: ${reason}`);
+        }));
+    }
+    for (;;) {
+        const outPtr = engine.input_reserve(16);
+        const handle = engine.soundfont_take_request(outPtr);
+        if (handle < 0) {
+            break;
+        }
+        const uuid = new Uint8Array(memory.buffer, outPtr, 16).slice();
+        track(engineToClient.fetchSoundfont(uuid).then(soundfont => {
+            const blob = new Uint8Array(simplifySoundfont(soundfont));
+            const pointer = engine.soundfont_allocate(handle, blob.byteLength);
+            if (pointer === 0) {
+                return;
+            } // dead handle (see the sample path): writing at 0 would corrupt memory
+            new Uint8Array(memory.buffer, pointer, blob.byteLength).set(blob);
+            engine.soundfont_set_ready(handle);
+        }, (reason) => engineToClient.log(`soundfont load failed: ${reason}`)));
+    }
+};

package/dist/device-linker.d.ts

@@ -0,0 +1,47 @@
+export declare const DEVICE_STACK_SIZE: number;
+export type BridgeImports = Record<string, (...args: Array<number>) => number | void>;
+export type DeviceExports = {
+    process?: (descPtr: number) => void;
+    process_events?: (from: number, to: number, flags: number, statePtr: number, outPtr: number, max: number) => number;
+    state_size: (sampleRate: number) => number;
+    kind: () => number;
+    init?: (statePtr: number, sampleRate: number) => void;
+    parameter_changed?: (statePtr: number, id: number, kind: number, value: number) => void;
+    field_changed?: (statePtr: number, id: number, kind: number, bits: number, len: number) => void;
+    sample_changed?: (statePtr: number, id: number, handle: number, present: number) => void;
+    soundfont_changed?: (statePtr: number, id: number, handle: number, present: number) => void;
+    reset?: (statePtr: number) => void;
+    terminate?: (statePtr: number) => void;
+    midi_effects_field?: () => number;
+    audio_effects_field?: () => number;
+    observe_param_collection_field?: () => number;
+    observe_sample_collection_field?: () => number;
+    __wasm_apply_data_relocs?: () => void;
+    __wasm_call_ctors?: () => void;
+};
+export type LinkerEngine = {
+    device_alloc: (size: number) => number;
+    device_register: (processIndex: number, stateSize: number, kind: number, initIndex: number, parameterChangedIndex: number, fieldChangedIndex: number, sampleChangedIndex: number, soundfontChangedIndex: number, resetIndex: number, terminateIndex: number, midiEffectsField: number, audioEffectsField: number, paramCollectionField: number, sampleCollectionField: number) => number;
+    device_set_box_type: (deviceId: number, nameLen: number) => void;
+    composite_register: (nameLen: number, childrenField: number, indexKey: number, excludeKey: number, cellInstrumentField: number, cellMidiField: number, cellAudioField: number, childEnabledKey: number, childMuteKey: number, childSoloKey: number) => void;
+    input_reserve: (len: number) => number;
+};
+export type CompositeRegistration = {
+    boxType: string;
+    childrenField: number;
+    indexKey: number;
+    excludeKey: number;
+    cellInstrumentField: number;
+    cellMidiField: number;
+    cellAudioField: number;
+    childEnabledKey: number;
+    childMuteKey: number;
+    childSoloKey: number;
+};
+export declare const parseDylink: (module: WebAssembly.Module) => {
+    memorySize: number;
+    tableSize: number;
+};
+export declare const linkDevice: (engine: LinkerEngine, memory: WebAssembly.Memory, table: WebAssembly.Table, module: WebAssembly.Module, boxType: string, sampleRate: number, bridgeImports: BridgeImports) => void;
+export declare const registerComposite: (engine: LinkerEngine, memory: WebAssembly.Memory, spec: CompositeRegistration) => void;
+//# sourceMappingURL=device-linker.d.ts.map

package/dist/device-linker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-linker.d.ts","sourceRoot":"","sources":["../src/device-linker.ts"],"names":[],"mappings":"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"}

package/dist/device-linker.js

@@ -0,0 +1,109 @@
+// The ONE owner of the device side-module linking ritual, shared by the worklet (engine-processor.ts), the
+// perf worker (perf/offline-render.ts), and the test loader (test/helpers/load-full-engine.ts). Everything a
+// device needs to join the engine lives here: the `dylink.0` parse, the talc base/stack allocation, the env
+// (including the SINGLE authoritative host-import list), relocations, table installation, registration, and
+// the box-type / composite name mapping. A new engine export added here reaches every context at once; a
+// loader that misses one fails LOUDLY at link time with the import's name instead of a cryptic LinkError.
+export const DEVICE_STACK_SIZE = 256 * 1024; // talc-allocated stack handed to each loaded device
+// The engine exports a device side-module imports from `env` (wasm-to-wasm via the loader binding). This
+// list is the CONTRACT: extend it here when the engine gains a host export, never in a loader.
+const HOST_IMPORTS = [
+    "host_pull_events", "host_pulse_to_offset",
+    "host_bind_parameter", "host_bind_broadcast", "host_broadcast_ptr", "host_broadcast_active",
+    "host_update_parameters", "host_first_update_position", "host_next_update_position",
+    "host_resolve_sample", "host_observe_sample",
+    "host_resolve_soundfont", "host_observe_soundfont",
+    "host_observe_field", "host_observe_target_string",
+    "host_bind_sidechain", "host_resolve_input", "host_self_uuid", "host_panic",
+    "host_base_frequency"
+];
+const readVarU32 = (bytes, pos) => {
+    let result = 0, shift = 0, cursor = pos;
+    for (;;) {
+        const byte = bytes[cursor++];
+        result |= (byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            break;
+        }
+        shift += 7;
+    }
+    return [result >>> 0, cursor];
+};
+// Read a PIC side module's memory/table requirements from its `dylink.0` custom section.
+export const parseDylink = (module) => {
+    const sections = WebAssembly.Module.customSections(module, "dylink.0");
+    if (sections.length === 0) {
+        return { memorySize: 0, tableSize: 0 };
+    }
+    const bytes = new Uint8Array(sections[0]);
+    let pos = 0;
+    while (pos < bytes.length) {
+        const type = bytes[pos++];
+        const [size, afterSize] = readVarU32(bytes, pos);
+        if (type === 1) {
+            const [memorySize, afterMem] = readVarU32(bytes, afterSize);
+            const [, afterAlign] = readVarU32(bytes, afterMem);
+            const [tableSize] = readVarU32(bytes, afterAlign);
+            return { memorySize, tableSize };
+        }
+        pos = afterSize + size;
+    }
+    return { memorySize: 0, tableSize: 0 };
+};
+// Write an ASCII box-type name into the engine's input scratch (no TextEncoder in the worklet scope).
+const writeName = (engine, memory, name) => {
+    const length = name.length;
+    const pointer = engine.input_reserve(length);
+    const bytes = new Uint8Array(memory.buffer, pointer, length);
+    for (let index = 0; index < length; index++) {
+        bytes[index] = name.charCodeAt(index) & 0xff;
+    }
+    return length;
+};
+// Link ONE device PIC side module into the engine: assign it memory + table + stack bases from talc,
+// instantiate with the authoritative host imports plus the JS bridge closures, apply its relocations,
+// install its `process` (or MIDI-fx `process_events`) into the shared table, install the optional hooks,
+// register it, and map its device-box type.
+export const linkDevice = (engine, memory, table, module, boxType, sampleRate, bridgeImports) => {
+    const { memorySize, tableSize } = parseDylink(module);
+    const memoryBase = engine.device_alloc(memorySize);
+    const tableBase = tableSize > 0 ? table.grow(tableSize) : table.length;
+    const stackBase = engine.device_alloc(DEVICE_STACK_SIZE);
+    const env = {
+        memory, __indirect_function_table: table,
+        __memory_base: new WebAssembly.Global({ value: "i32", mutable: false }, memoryBase),
+        __table_base: new WebAssembly.Global({ value: "i32", mutable: false }, tableBase),
+        __stack_pointer: new WebAssembly.Global({ value: "i32", mutable: true }, stackBase + DEVICE_STACK_SIZE)
+    };
+    for (const name of HOST_IMPORTS) {
+        const fn = engine[name];
+        if (typeof fn !== "function") {
+            throw new Error(`engine is missing the device host export '${name}'`);
+        }
+        env[name] = fn;
+    }
+    Object.assign(env, bridgeImports);
+    const device = new WebAssembly.Instance(module, { env: env }).exports;
+    device.__wasm_apply_data_relocs?.();
+    device.__wasm_call_ctors?.();
+    // Install an optional device export into a fresh table slot, 0 = "none" (device slots are grown above
+    // the engine's own table functions, so a real hook is never at 0).
+    const installOptional = (fn) => {
+        if (fn === undefined) {
+            return 0;
+        }
+        const index = table.grow(1);
+        table.set(index, fn);
+        return index;
+    };
+    // An audio device installs `process`; a MIDI-fx device installs `process_events` (its pull responder).
+    const processIndex = table.grow(1);
+    table.set(processIndex, (device.process_events ?? device.process));
+    const deviceId = engine.device_register(processIndex, device.state_size(sampleRate), device.kind(), installOptional(device.init), installOptional(device.parameter_changed), installOptional(device.field_changed), installOptional(device.sample_changed), installOptional(device.soundfont_changed), installOptional(device.reset), installOptional(device.terminate), device.midi_effects_field?.() ?? 0, device.audio_effects_field?.() ?? 0, device.observe_param_collection_field?.() ?? 0, device.observe_sample_collection_field?.() ?? 0);
+    engine.device_set_box_type(deviceId, writeName(engine, memory, boxType));
+};
+// Register one COMPOSITE box type (a box hosting a child collection of its own instruments): write its
+// name, then map its child collection fields. The child plugin itself is a normal `linkDevice` entry.
+export const registerComposite = (engine, memory, spec) => {
+    engine.composite_register(writeName(engine, memory, spec.boxType), spec.childrenField, spec.indexKey, spec.excludeKey, spec.cellInstrumentField, spec.cellMidiField, spec.cellAudioField, spec.childEnabledKey, spec.childMuteKey, spec.childSoloKey);
+};

package/dist/engine-exports.d.ts

@@ -0,0 +1,86 @@
+export type EngineExports = {
+    init: (sampleRate: number) => void;
+    device_alloc: (size: number) => number;
+    device_register: (processIndex: number, stateSize: number, kind: number, initIndex: number, parameterChangedIndex: number, fieldChangedIndex: number, sampleChangedIndex: number, soundfontChangedIndex: number, resetIndex: number, terminateIndex: number, midiEffectsField: number, audioEffectsField: number, paramCollectionField: number, sampleCollectionField: number) => number;
+    device_set_box_type: (deviceId: number, nameLen: number) => void;
+    composite_register: (nameLen: number, childrenField: number, indexKey: number, excludeKey: number, cellInstrumentField: number, cellMidiField: number, cellAudioField: number, childEnabledKey: number, childMuteKey: number, childSoloKey: number) => void;
+    input_ptr: () => number;
+    input_capacity: () => number;
+    input_reserve: (len: number) => number;
+    apply_updates: (len: number) => number;
+    bind: () => number;
+    render: () => void;
+    output_ptr: () => number;
+    output_len: () => number;
+    heap_used: () => number;
+    heap_claimed: () => number;
+    engine_state_ptr: () => number;
+    engine_state_len: () => number;
+    set_metronome_enabled: (enabled: number) => void;
+    set_metronome_gain: (gainDb: number) => void;
+    set_metronome_beat_sub_division: (division: number) => void;
+    set_metronome_monophonic: (enabled: number) => void;
+    click_allocate: (frameCount: number, channels: number) => number;
+    set_click_sound: (index: number, frameCount: number, channels: number, sampleRate: number) => void;
+    checksum_ptr: () => number;
+    broadcast_generation: () => number;
+    broadcast_count: () => number;
+    broadcast_entry: (index: number, outPtr: number) => number;
+    broadcast_set_active: (index: number, active: number) => void;
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+    set_position: (position: number) => void;
+    prepare_recording_state: (countIn: number, countInBars: number) => void;
+    stop_recording: () => void;
+    ignore_note_region: () => void;
+    set_monitoring_map: (count: number) => void;
+    monitor_input_ptr: () => number;
+    monitor_output_ptr: () => number;
+    set_stem_export: (count: number) => void;
+    stem_output_ptr: () => number;
+    frozen_allocate: (frameCount: number, channels: number) => number;
+    set_frozen_audio: (frameCount: number, channels: number, sampleRate: number) => void;
+    clear_frozen_audio: () => void;
+    note_signal_on: (pitch: number, velocity: number) => void;
+    note_signal_off: (pitch: number) => void;
+    note_signal_audition: (pitch: number, duration: number, velocity: number) => void;
+    schedule_clip_play: () => void;
+    schedule_clip_stop: () => void;
+    clip_changes_count: () => number;
+    clip_changes_take: (outPtr: number) => number;
+    marker_changes_count: () => number;
+    marker_changes_take: (outPtr: number) => number;
+    midi_out_count: () => number;
+    midi_out_take: (outPtr: number) => number;
+    midi_out_device_id: (num: number, outPtr: number, max: number) => number;
+    host_pull_events: (from: number, to: number, flags: number, outPtr: number, max: number) => number;
+    host_pulse_to_offset: (pulse: number) => number;
+    host_bind_parameter: (pathPtr: number, pathLen: number) => number;
+    host_update_parameters: (position: number, outPtr: number, max: number) => number;
+    host_first_update_position: (at: number) => number;
+    host_next_update_position: (after: number) => number;
+    host_resolve_sample: (handle: number, outPtr: number) => number;
+    host_resolve_soundfont: (handle: number, outPtr: number) => number;
+    host_observe_soundfont: (pathPtr: number, pathLen: number) => number;
+    soundfont_take_request: (outPtr: number) => number;
+    soundfont_allocate: (handle: number, byteLength: number) => number;
+    soundfont_set_ready: (handle: number) => void;
+    host_self_uuid: (outPtr: number) => void;
+    host_observe_sample: (pathPtr: number, pathLen: number) => number;
+    host_observe_field: (pathPtr: number, pathLen: number) => number;
+    host_observe_target_string: (pathPtr: number, pathLen: number, fieldKey: number) => number;
+    host_bind_sidechain: (pathPtr: number, pathLen: number) => number;
+    host_resolve_input: (id: number, outPtr: number) => number;
+    host_base_frequency: () => number;
+    sample_take_request: (outPtr: number) => number;
+    sample_allocate: (handle: number, byteLength: number) => number;
+    sample_set_ready: (handle: number, frameCount: number, channelCount: number, sampleRate: number) => void;
+    set_allow_takes: (enabled: number) => void;
+    set_pause_on_loop_disabled: (enabled: number) => void;
+    set_truncate_notes_at_region_end: (enabled: number) => void;
+    panic_message_ptr: () => number;
+    panic_message_len: () => number;
+};
+export declare const readPanicMessage: (exports: EngineExports, memory: WebAssembly.Memory) => string;
+//# sourceMappingURL=engine-exports.d.ts.map

package/dist/engine-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-exports.d.ts","sourceRoot":"","sources":["../src/engine-exports.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,aAAa,GAAG;IACxB,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IAItC,eAAe,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,KAAK,MAAM,CAAA;IAGxX,mBAAmB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAIhE,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3P,SAAS,EAAE,MAAM,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,MAAM,CAAA;IAC5B,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACtC,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACtC,IAAI,EAAE,MAAM,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,UAAU,EAAE,MAAM,MAAM,CAAA;IACxB,UAAU,EAAE,MAAM,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,MAAM,CAAA;IAC1B,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,qBAAqB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAIhD,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,+BAA+B,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3D,wBAAwB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAInD,cAAc,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;IAChE,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IAClG,YAAY,EAAE,MAAM,MAAM,CAAA;IAK1B,oBAAoB,EAAE,MAAM,MAAM,CAAA;IAClC,eAAe,EAAE,MAAM,MAAM,CAAA;IAC7B,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAC1D,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAG7D,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAGxC,uBAAuB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAA;IACvE,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAK9B,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,iBAAiB,EAAE,MAAM,MAAM,CAAA;IAC/B,kBAAkB,EAAE,MAAM,MAAM,CAAA;IAKhC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,eAAe,EAAE,MAAM,MAAM,CAAA;IAK7B,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;IACjE,gBAAgB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IACpF,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAI9B,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACzD,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAKjF,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,kBAAkB,EAAE,MAAM,MAAM,CAAA;IAChC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAK7C,oBAAoB,EAAE,MAAM,MAAM,CAAA;IAClC,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAO/C,cAAc,EAAE,MAAM,MAAM,CAAA;IAC5B,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IACzC,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IAGxE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IAGlG,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAM/C,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;IACjE,sBAAsB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACjF,0BAA0B,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAA;IAClD,yBAAyB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAMpD,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/D,sBAAsB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAClE,sBAAsB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;IACpE,sBAAsB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAClD,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAA;IAClE,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAG7C,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;IACjE,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;IAGhE,0BAA0B,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;IAI1F,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;IACjE,kBAAkB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAG1D,mBAAmB,EAAE,MAAM,MAAM,CAAA;IACjC,mBAAmB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/C,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/D,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IAIxG,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,0BAA0B,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACrD,gCAAgC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IAI3D,iBAAiB,EAAE,MAAM,MAAM,CAAA;IAC/B,iBAAiB,EAAE,MAAM,MAAM,CAAA;CAClC,CAAA;AAKD,eAAO,MAAM,gBAAgB,GAAI,SAAS,aAAa,EAAE,QAAQ,WAAW,CAAC,MAAM,KAAG,MAIrF,CAAA"}

package/dist/engine-exports.js

@@ -0,0 +1,13 @@
+// The engine wasm module's export surface, shared by every host that instantiates it (the wasm app's own
+// worklet, the offline perf renderer, and the studio's wasm engine processor).
+import { decodeUtf8 } from "./utf8";
+// Read the panic message the trapped engine left behind (empty when the failure was not a wasm panic).
+// Decoded WITHOUT TextDecoder — the AudioWorkletGlobalScope has none, and this runs exactly when a
+// worklet must report a panic.
+export const readPanicMessage = (exports, memory) => {
+    const length = exports.panic_message_len();
+    if (length === 0) {
+        return "";
+    }
+    return decodeUtf8(new Uint8Array(memory.buffer, exports.panic_message_ptr(), length));
+};

package/dist/engine-modules.d.ts

@@ -0,0 +1,26 @@
+export type CompositeSpec = {
+    boxType: string;
+    childrenField: number;
+    indexKey: number;
+    excludeKey: number;
+    cellInstrumentField: number;
+    cellMidiField: number;
+    cellAudioField: number;
+    childEnabledKey: number;
+    childMuteKey: number;
+    childSoloKey: number;
+};
+export type EngineModules = {
+    engineModule: WebAssembly.Module;
+    deviceModules: ReadonlyArray<WebAssembly.Module>;
+    deviceBoxTypes: ReadonlyArray<string>;
+    composites: ReadonlyArray<CompositeSpec>;
+};
+export declare const createEngineMemory: () => WebAssembly.Memory;
+export declare const DEVICES: ReadonlyArray<{
+    url: string;
+    boxType: string;
+}>;
+export declare const COMPOSITES: ReadonlyArray<CompositeSpec>;
+export declare const loadEngineModules: (base?: string) => Promise<EngineModules>;
+//# sourceMappingURL=engine-modules.d.ts.map

package/dist/engine-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-modules.d.ts","sourceRoot":"","sources":["../src/engine-modules.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,aAAa,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAG7E,mBAAmB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAE3E,eAAe,EAAE,MAAM,CAAC;IAGxB,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IACxB,YAAY,EAAE,WAAW,CAAC,MAAM,CAAA;IAChC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;IAChD,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACrC,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;CAC3C,CAAA;AAMD,eAAO,MAAM,kBAAkB,QAAO,WAAW,CAAC,MACsB,CAAA;AAMxE,eAAO,MAAM,OAAO,EAAE,aAAa,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA0BnE,CAAA;AAKD,eAAO,MAAM,UAAU,EAAE,aAAa,CAAC,aAAa,CAWnD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAU,OAAM,MAAW,KAAG,OAAO,CAAC,aAAa,CAOhF,CAAA"}