@opendaw/studio-core-wasm 0.0.2

package/dist/engine-modules.js

@@ -0,0 +1,62 @@
+// Fetch + compile the wasm modules the engine worklet needs: the engine (the dynamic-linker host) and
+// the device PLUGINS (PIC side modules the engine loads at host-assigned bases). All are handed to the
+// "engine" AudioWorkletProcessor via processorOptions; the worklet links the devices into the engine.
+// The engine's single linear memory: SHARED, so the main thread can see the WASM heap (e.g. to write
+// decoded sample data straight into it at an engine-allocated offset). wasm32 caps at 65536 pages (4 GiB),
+// so that is the maximum; pages commit lazily on grow. Needs cross-origin isolation (COOP/COEP, set in
+// vite.config). Created on the main thread and passed into the worklet via processorOptions.
+export const createEngineMemory = () => new WebAssembly.Memory({ initial: 256, maximum: 65536, shared: true });
+// The device PIC side modules to load: each wasm plus the device-BOX TYPE it realizes. This is the device
+// table the engine uses to instantiate a device box: when the box graph presents e.g. an ArpeggioDeviceBox,
+// the engine looks up its type here to find its plugin under /wasm/plugins/. Load order is irrelevant now (the engine reads
+// each unit's chains from the box, ordered by the device `index`); only the type mapping matters.
+export const DEVICES = [
+    { url: "/wasm/plugins/device_vaporisateur.wasm", boxType: "VaporisateurDeviceBox" }, // instrument
+    { url: "/wasm/plugins/device_nano.wasm", boxType: "NanoDeviceBox" }, // instrument (sampler)
+    { url: "/wasm/plugins/device_revamp.wasm", boxType: "RevampDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_tidal.wasm", boxType: "TidalDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_delay.wasm", boxType: "DelayDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_gate.wasm", boxType: "GateDeviceBox" }, // audio effect (sidechain)
+    { url: "/wasm/plugins/device_arpeggio.wasm", boxType: "ArpeggioDeviceBox" }, // midi effect
+    { url: "/wasm/plugins/device_zeitgeist.wasm", boxType: "ZeitgeistDeviceBox" }, // midi effect
+    { url: "/wasm/plugins/device_pitch.wasm", boxType: "PitchDeviceBox" }, // midi effect
+    { url: "/wasm/plugins/device_werkstatt.wasm", boxType: "WerkstattDeviceBox" }, // scriptable audio effect
+    { url: "/wasm/plugins/device_apparat.wasm", boxType: "ApparatDeviceBox" }, // scriptable instrument
+    { url: "/wasm/plugins/device_spielwerk.wasm", boxType: "SpielwerkDeviceBox" }, // scriptable midi effect
+    { url: "/wasm/plugins/device_waveshaper.wasm", boxType: "WaveshaperDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_crusher.wasm", boxType: "CrusherDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_fold.wasm", boxType: "FoldDeviceBox" }, // audio effect (wavefolder)
+    { url: "/wasm/plugins/device_stereo_tool.wasm", boxType: "StereoToolDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_velocity.wasm", boxType: "VelocityDeviceBox" }, // midi effect
+    { url: "/wasm/plugins/device_maximizer.wasm", boxType: "MaximizerDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_compressor.wasm", boxType: "CompressorDeviceBox" }, // audio effect (sidechain)
+    { url: "/wasm/plugins/device_reverb.wasm", boxType: "ReverbDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_dattorro_reverb.wasm", boxType: "DattorroReverbDeviceBox" }, // audio effect
+    { url: "/wasm/plugins/device_soundfont.wasm", boxType: "SoundfontDeviceBox" }, // instrument (preset sampler)
+    { url: "/wasm/plugins/device_vocoder.wasm", boxType: "VocoderDeviceBox" }, // audio effect (channel vocoder + sidechain)
+    { url: "/wasm/plugins/device_neural_amp.wasm", boxType: "NeuralAmpDeviceBox" }, // audio effect (NAM, via the nam bridge)
+    { url: "/wasm/plugins/device_playfield_sample.wasm", boxType: "PlayfieldSampleBox" } // composite child (one Playfield slot)
+];
+// The composite box types. Playfield hosts its slots in the `samples` field (key 10); each slot's note is its
+// `index` field (key 15) and its choke-group flag is `exclude` (key 42). The slot plugin itself is the
+// PlayfieldSampleBox entry in DEVICES above.
+export const COMPOSITES = [
+    // Playfield: direct children (self-hosting slots, device-declared chains), routed by note index + choke.
+    { boxType: "PlayfieldDeviceBox", childrenField: 10, indexKey: 15, excludeKey: 42,
+        cellInstrumentField: 0, cellMidiField: 0, cellAudioField: 0, childEnabledKey: 22,
+        childMuteKey: 40, childSoloKey: 41 },
+    // A generic instrument bundle: children are CELLS (CompositeCellBox) at field 10, each wrapping one
+    // instrument (field 2) plus its midi-fx (3) and audio-fx (4) chains, ordered by the cell's own `index`
+    // (field 5, UI position + engine sort). No note routing, no choke.
+    { boxType: "CompositeDeviceBox", childrenField: 10, indexKey: 5, excludeKey: 0,
+        cellInstrumentField: 2, cellMidiField: 3, cellAudioField: 4, childEnabledKey: 0,
+        childMuteKey: 0, childSoloKey: 0 }
+];
+export const loadEngineModules = async (base = "") => {
+    const urls = [`${base}/wasm/engine.wasm`, ...DEVICES.map(device => `${base}${device.url}`)];
+    const buffers = await Promise.all(urls.map(url => fetch(url).then(response => response.ok
+        ? response.arrayBuffer()
+        : Promise.reject(new Error(`Could not load wasm module '${url}' (${response.status} ${response.statusText})`)))));
+    const [engineModule, ...deviceModules] = await Promise.all(buffers.map(bytes => WebAssembly.compile(bytes)));
+    return { engineModule, deviceModules, deviceBoxTypes: DEVICES.map(device => device.boxType), composites: COMPOSITES };
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./WasmEngine";
+export * from "./engine-modules";
+export type { EngineExports } from "./engine-exports";
+export { readPanicMessage } from "./engine-exports";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,YAAY,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAC,gBAAgB,EAAC,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,6 @@
+// The published main-thread surface of the WASM engine. The worklet/worker side ships as prebuilt bundles
+// (dist/wasm-processor.js, dist/wasm-offline-worker.js) next to the wasm binaries (dist/wasm/*); a host
+// serves those and hands their URLs to `WasmEngine.install`.
+export * from "./WasmEngine";
+export * from "./engine-modules";
+export { readPanicMessage } from "./engine-exports";

package/dist/nam-bridge.d.ts

@@ -0,0 +1,7 @@
+export declare class NamBridges {
+    #private;
+    constructor(memory: WebAssembly.Memory, fetchWasm: () => Promise<ArrayBuffer>, sampleRate: number);
+    settle(): Promise<void>;
+    imports(): Record<string, (...args: Array<number>) => number | void>;
+}
+//# sourceMappingURL=nam-bridge.d.ts.map

package/dist/nam-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nam-bridge.d.ts","sourceRoot":"","sources":["../src/nam-bridge.ts"],"names":[],"mappings":"AAsCA,qBAAa,UAAU;;gBAYP,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,EAAE,UAAU,EAAE,MAAM;IAS3F,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAK7B,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,MAAM,GAAG,IAAI,CAAC;CAsKvE"}

package/dist/nam-bridge.js

@@ -0,0 +1,265 @@
+// The NAM BRIDGE: the JS side of the NeuralAmp device. Its Rust side-module does the wrapper DSP (gains,
+// mono downmix, dry/wet mix) and calls the `host_nam_*` env imports defined here, which run the SAME
+// `@opendaw/nam-wasm` module (NeuralAmpModelerCore, A2-capable) the TS engine's `NeuralAmpDeviceProcessor`
+// runs — instantiated as its OWN wasm instance next to the engine (an Emscripten build cannot join the
+// engine's shared memory). Per chunk the bridge copies ≤128 samples per channel between the two memories,
+// negligible next to the inference. Like the SCRIPT BRIDGE, this is a contained relaxation of the engine's
+// zero-JS-in-render rule.
+//
+// Identity: the device's `init` calls `host_nam_create(uuidPtr)` -> a handle KEYED BY THE DEVICE BOX UUID, so
+// a rebind reuses the existing instances and their loaded (prewarmed) model. The model JSON arrives as raw
+// UTF-8 bytes out of the ENGINE's memory (`observe_target_string` on the device's model pointer) and is
+// copied straight into the nam heap — no JS string, no TextDecoder (the worklet scope has none).
+// Byte-identical deliveries (rebind catch-ups) are skipped. The nam module itself loads LAZILY on the first
+// model delivery; until it is ready `host_nam_process` reports not-loaded and the device passes through,
+// mirroring the TS processor while its wasm fetch is in flight.
+import { isDefined, UUID } from "@opendaw/lib-std";
+import { createNamModule, NamWasmModule } from "@opendaw/nam-wasm";
+// One NeuralAmp device's JS-side state, keyed by the handle `host_nam_create` returned. `instances` mirrors
+// the TS processor's `#instances: [int, int]` (mono uses only the first; -1 = none).
+class Bridge {
+    uuid;
+    instances = [-1, -1];
+    json = null; // the cached model bytes; null = no model (unloaded)
+    loaded = false;
+    mono = true;
+    constructor(uuid) {
+        this.uuid = uuid;
+    }
+}
+const bytesEqual = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let index = 0; index < a.length; index++) {
+        if (a[index] !== b[index]) {
+            return false;
+        }
+    }
+    return true;
+};
+export class NamBridges {
+    #memory;
+    #fetchWasm;
+    #sampleRate;
+    #bridges = new Map();
+    #byUuid = new Map();
+    #nextHandle = 1;
+    #emscripten = null;
+    #module = null;
+    #loading = false;
+    #failed = false;
+    constructor(memory, fetchWasm, sampleRate) {
+        this.#memory = memory;
+        this.#fetchWasm = fetchWasm;
+        this.#sampleRate = sampleRate;
+    }
+    /// Resolves once no module fetch/instantiation is in flight (models are applied synchronously when it
+    /// lands). For tests: after a bind delivered a model, `await settle()` guarantees `host_nam_process` stops
+    /// reporting not-loaded (or the load genuinely failed).
+    async settle() {
+        while (this.#loading) {
+            await new Promise(resolve => setTimeout(resolve, 1));
+        }
+    }
+    /// The `host_nam_*` closures to bind into each device's `env`.
+    imports() {
+        return {
+            host_nam_create: (uuidPtr) => this.#create(uuidPtr),
+            host_nam_load: (handle, jsonPtr, jsonLen) => this.#load(handle, jsonPtr, jsonLen),
+            host_nam_set_mono: (handle, mono) => this.#setMono(handle, mono !== 0),
+            host_nam_process: (handle, in0, in1, out0, out1, frames, channels) => this.#process(handle, in0, in1, out0, out1, frames, channels),
+            host_nam_reset: (handle) => this.#reset(handle),
+            host_nam_release: (handle) => this.#release(handle)
+        };
+    }
+    #create(uuidPtr) {
+        const uuid = UUID.toString(new Uint8Array(this.#memory.buffer, uuidPtr, 16).slice());
+        const existing = this.#byUuid.get(uuid);
+        if (isDefined(existing)) {
+            return existing;
+        }
+        const handle = this.#nextHandle++;
+        this.#bridges.set(handle, new Bridge(uuid));
+        this.#byUuid.set(uuid, handle);
+        return handle;
+    }
+    // The model delivery: copy the JSON bytes out of the engine memory SYNCHRONOUSLY (they borrow the box
+    // graph only for this call), dedupe against the cached bytes, and load / unload the instances. Kicks the
+    // lazy module fetch on the first real model.
+    #load(handle, jsonPtr, jsonLen) {
+        const bridge = this.#bridges.get(handle);
+        if (!isDefined(bridge)) {
+            return;
+        }
+        if (jsonLen === 0) {
+            bridge.json = null;
+            this.#unloadInstances(bridge);
+            return;
+        }
+        const json = new Uint8Array(this.#memory.buffer, jsonPtr, jsonLen).slice();
+        if (isDefined(bridge.json) && bytesEqual(bridge.json, json)) {
+            return;
+        }
+        bridge.json = json;
+        if (isDefined(this.#module)) {
+            this.#applyModel(bridge);
+        }
+        else {
+            this.#ensureModule();
+        }
+    }
+    // Mirror the TS `#onMonoChanged`: mono drops the second instance; stereo creates it and loads the cached
+    // model into it.
+    #setMono(handle, mono) {
+        const bridge = this.#bridges.get(handle);
+        if (!isDefined(bridge)) {
+            return;
+        }
+        bridge.mono = mono;
+        const module = this.#module;
+        if (!isDefined(module)) {
+            return;
+        }
+        if (mono) {
+            if (bridge.instances[1] >= 0) {
+                module.unloadModel(bridge.instances[1]);
+                module.destroyInstance(bridge.instances[1]);
+                bridge.instances[1] = -1;
+            }
+        }
+        else if (bridge.instances[1] < 0) {
+            bridge.instances[1] = module.createInstance();
+            if (isDefined(bridge.json) && bridge.loaded) {
+                bridge.loaded = this.#loadInto(bridge.instances[1], bridge.json) && bridge.loaded;
+            }
+        }
+    }
+    // One chunk of both channels: Float32Array views over the ENGINE memory (re-derived every call — the
+    // SharedArrayBuffer can grow), copied through the nam heap by `NamWasmModule.process`. Returns 1 only when
+    // the model is loaded; 0 is the device's passthrough cue (module still loading / no model / unknown handle).
+    #process(handle, in0, in1, out0, out1, frames, channels) {
+        const bridge = this.#bridges.get(handle);
+        const module = this.#module;
+        if (!isDefined(bridge) || !isDefined(module) || !bridge.loaded || bridge.instances[0] < 0) {
+            return 0;
+        }
+        const buffer = this.#memory.buffer;
+        module.process(bridge.instances[0], new Float32Array(buffer, in0, frames), new Float32Array(buffer, out0, frames));
+        if (channels > 1) {
+            if (bridge.instances[1] < 0) {
+                return 0;
+            }
+            module.process(bridge.instances[1], new Float32Array(buffer, in1, frames), new Float32Array(buffer, out1, frames));
+        }
+        return 1;
+    }
+    #reset(handle) {
+        const bridge = this.#bridges.get(handle);
+        const module = this.#module;
+        if (!isDefined(bridge) || !isDefined(module)) {
+            return;
+        }
+        for (const instance of bridge.instances) {
+            if (instance >= 0) {
+                module.reset(instance);
+            }
+        }
+    }
+    // THIS device's instance is dying (a genuine removal, never a chain-edit survivor, called from the
+    // engine's `terminate` export): destroy its native nam instance(s) and drop the bridge, so a removed or
+    // rebound NeuralAmp device no longer keeps its instance(s) resident forever.
+    #release(handle) {
+        const bridge = this.#bridges.get(handle);
+        if (!isDefined(bridge)) {
+            return;
+        }
+        const module = this.#module;
+        if (isDefined(module)) {
+            for (const instance of bridge.instances) {
+                if (instance >= 0) {
+                    module.unloadModel(instance);
+                    module.destroyInstance(instance);
+                }
+            }
+        }
+        this.#bridges.delete(handle);
+        if (this.#byUuid.get(bridge.uuid) === handle) {
+            this.#byUuid.delete(bridge.uuid);
+        }
+    }
+    // Fetch + instantiate the nam module ONCE (lazily, off the render path), then apply every bridge's pending
+    // model. A failure logs and stays failed: every device keeps passing through, the TS engine's behavior.
+    #ensureModule() {
+        if (this.#loading || this.#failed || isDefined(this.#module)) {
+            return;
+        }
+        this.#loading = true;
+        this.#fetchWasm()
+            .then(wasmBinary => createNamModule({ wasmBinary, locateFile: () => "" }))
+            .then(emscripten => {
+            this.#emscripten = emscripten;
+            const module = NamWasmModule.fromModule(emscripten);
+            module.setSampleRate(this.#sampleRate);
+            this.#module = module;
+            this.#loading = false;
+            for (const bridge of this.#bridges.values()) {
+                if (isDefined(bridge.json)) {
+                    this.#applyModel(bridge);
+                }
+            }
+        })
+            .catch(error => {
+            this.#loading = false;
+            this.#failed = true;
+            console.error("Failed to load NAM WASM:", error);
+        });
+    }
+    // Mirror the TS `#applyModel`: ensure the instances match the mono flag, then load the cached JSON into
+    // each. `loaded` gates `#process`, so a failed load keeps the device passing through.
+    #applyModel(bridge) {
+        const module = this.#module;
+        if (!isDefined(module) || !isDefined(bridge.json)) {
+            return;
+        }
+        if (bridge.instances[0] < 0) {
+            bridge.instances[0] = module.createInstance();
+        }
+        if (!bridge.mono && bridge.instances[1] < 0) {
+            bridge.instances[1] = module.createInstance();
+        }
+        bridge.loaded = this.#loadInto(bridge.instances[0], bridge.json);
+        if (bridge.instances[1] >= 0) {
+            bridge.loaded = this.#loadInto(bridge.instances[1], bridge.json) && bridge.loaded;
+        }
+    }
+    #unloadInstances(bridge) {
+        bridge.loaded = false;
+        const module = this.#module;
+        if (!isDefined(module)) {
+            return;
+        }
+        for (const instance of bridge.instances) {
+            if (instance >= 0) {
+                module.unloadModel(instance);
+            }
+        }
+    }
+    // Load raw model bytes into one nam instance: straight into the nam heap (NUL-terminated), no JS string —
+    // `NamWasmModule.loadModel` marshals a string, but the worklet scope has no TextDecoder to make one.
+    #loadInto(instance, json) {
+        const emscripten = this.#emscripten;
+        if (!isDefined(emscripten)) {
+            return false;
+        }
+        const jsonPtr = emscripten._malloc(json.length + 1);
+        emscripten.HEAPU8.set(json, jsonPtr);
+        emscripten.HEAPU8[jsonPtr + json.length] = 0;
+        const loaded = emscripten._nam_loadModel(instance, jsonPtr);
+        emscripten._free(jsonPtr);
+        if (!loaded) {
+            console.error("NAM loadModel failed");
+        }
+        return !!loaded;
+    }
+}

package/dist/nam-loader.d.ts

@@ -0,0 +1,4 @@
+export interface NamLoader {
+    fetchWasm(): Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=nam-loader.d.ts.map

package/dist/nam-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nam-loader.d.ts","sourceRoot":"","sources":["../src/nam-loader.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,SAAS;IACtB,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,CAAA;CACpC"}

package/dist/nam-loader.js

@@ -0,0 +1 @@
+export {};

package/dist/protocol.d.ts

@@ -0,0 +1,22 @@
+import type { UUID } from "@opendaw/lib-std";
+import type { CompositeSpec } from "./engine-modules";
+export type WasmEngineAttachment = {
+    engineModule: WebAssembly.Module;
+    deviceModules: ReadonlyArray<WebAssembly.Module>;
+    deviceBoxTypes: ReadonlyArray<string>;
+    composites: ReadonlyArray<CompositeSpec>;
+    memory: WebAssembly.Memory;
+};
+export interface WasmSyncProtocol {
+    applyUpdates(bytes: ArrayBuffer): void;
+    checksum(bytes: Int8Array): Promise<void>;
+}
+export interface WasmFrozenProtocol {
+    frozenAllocate(frameCount: number, channels: number): Promise<number>;
+    frozenAttach(uuid: UUID.Bytes, frameCount: number, channels: number, sampleRate: number): void;
+    frozenClear(uuid: UUID.Bytes): void;
+}
+export declare const WASM_ENGINE_PROCESSOR_NAME = "engine-wasm-processor";
+export declare const WASM_SYNC_CHANNEL = "engine-sync-bytes";
+export declare const WASM_FROZEN_CHANNEL = "engine-frozen-audio";
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAC1C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAA;AAGnD,MAAM,MAAM,oBAAoB,GAAG;IAC/B,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;IACxC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAA;CAC7B,CAAA;AAMD,MAAM,WAAW,gBAAgB;IAC7B,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAA;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5C;AAMD,MAAM,WAAW,kBAAkB;IAC/B,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACrE,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9F,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;CACtC;AAED,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,iBAAiB,sBAAsB,CAAA;AACpD,eAAO,MAAM,mBAAmB,wBAAwB,CAAA"}

package/dist/protocol.js

@@ -0,0 +1,3 @@
+export const WASM_ENGINE_PROCESSOR_NAME = "engine-wasm-processor";
+export const WASM_SYNC_CHANNEL = "engine-sync-bytes";
+export const WASM_FROZEN_CHANNEL = "engine-frozen-audio";

package/dist/script-bridge.d.ts

@@ -0,0 +1,11 @@
+export interface ScriptEngine {
+    host_resolve_sample(handle: number, outPtr: number): number;
+    input_reserve(length: number): number;
+}
+export declare class ScriptBridges {
+    #private;
+    constructor(memory: WebAssembly.Memory, engine: ScriptEngine, sampleRate: number, onMessage?: (uuid: string, message: string) => void);
+    imports(): Record<string, (...args: number[]) => number | void>;
+    liveBridgeCount(): number;
+}
+//# sourceMappingURL=script-bridge.d.ts.map

package/dist/script-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-bridge.d.ts","sourceRoot":"","sources":["../src/script-bridge.ts"],"names":[],"mappings":"AA2CA,MAAM,WAAW,YAAY;IACzB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3D,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CACxC;AAsDD,qBAAa,aAAa;;gBASV,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EACpE,SAAS,GAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAe;IAQzE,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,IAAI,CAAC;IA+M/D,eAAe,IAAI,MAAM;CAG5B"}