@opendaw/studio-core-wasm 0.0.2

package/dist/script-bridge.js

@@ -0,0 +1,343 @@
+// The SCRIPT BRIDGE: the JS side of the three scriptable devices (Werkstatt / Apparat / Spielwerk). Their Rust
+// side-modules do no DSP — per block they call the `host_script_*` env imports defined here, which run the user
+// `Processor` (registered by the app at `globalThis.openDAW.<registry>[uuid]`) over the engine's shared linear
+// memory. So the SAME user JavaScript executes in the WASM engine as in the pure-TS engine; only the plumbing
+// differs. This is the one place the engine's zero-JS-in-render rule is relaxed, and it is contained entirely
+// here + in the three thin device crates. The bridge mirrors the TS `WerkstattDeviceProcessor` /
+// `ApparatDeviceProcessor` / `SpielwerkDeviceProcessor`: hot-swap by the registry `update` counter, the same
+// output validation (NaN / overflow -> silence), the SimpleLimiter (Apparat), and the param value mapping.
+//
+// Identity: the device's `init` calls `host_script_create(uuidPtr, kind, statePtr)` -> a handle; every later
+// call passes that handle. Buffers are byte offsets into the ONE shared memory; we re-derive `memory.buffer`
+// views EVERY call, since the SharedArrayBuffer can grow / detach (talc), never caching a typed-array view.
+import { isDefined, UUID, ValueMapping } from "@opendaw/lib-std";
+import { SimpleLimiter } from "@opendaw/lib-dsp";
+import { runSpielwerk, SpielwerkRuntime } from "./script-spielwerk";
+const RENDER_QUANTUM = 128;
+// ~1 second of render calls (128-frame quanta at 48k) before a scriptless device is reported — long enough to
+// cover a script still compiling / addModule-ing async, short enough to surface a genuine misconfiguration.
+const MISSING_GRACE_CALLS = 375;
+// Device kinds (mirror abi DEVICE_KIND_*) and their script registries.
+const KIND_INSTRUMENT = 0;
+const KIND_AUDIO_EFFECT = 1;
+const KIND_MIDI_EFFECT = 2;
+const REGISTRY_BY_KIND = {
+    [KIND_INSTRUMENT]: "apparatProcessors",
+    [KIND_AUDIO_EFFECT]: "werkstattProcessors",
+    [KIND_MIDI_EFFECT]: "spielwerkProcessors"
+};
+// Parameter wire kinds (mirror abi PARAM_KIND_*): UNIT is a 0..1 automation value to MAP; the rest are already
+// the real (un-automated) field value, used directly.
+const PARAM_KIND_UNIT = 0;
+const MAX_AMPLITUDE = 1000.0; // ~60 dB; matches the TS processors' validateOutput
+// One scriptable device instance's JS-side state, keyed by the handle `host_script_create` returned.
+class Bridge {
+    uuid;
+    kind;
+    registryName;
+    proc = null;
+    currentUpdate = -1;
+    silenced = false;
+    // index -> {label, valueMapping}; built from the registry entry's parsed @param declarations.
+    paramMappings = new Map();
+    // index -> the raw (kind, value) the engine last delivered. Cached so a value pushed BEFORE the proc loads
+    // (the engine pushes initial / automated params at bind, before the first render builds the mappings) is
+    // replayed once the proc + mappings exist, and re-mapped through the NEW mapping on a hot-swap.
+    rawParams = new Map();
+    // index -> label, for @sample slots (Apparat); the resolved sample handle is cached so a hot-swap re-delivers.
+    sampleLabels = new Map();
+    sampleHandles = new Map(); // index -> resolved engine sample handle (-1 = no sample; 0 is valid)
+    limiter = null;
+    spielwerk = null;
+    // A scriptable device with no registered Processor renders silence. That is legitimate for a block or two
+    // while the script loads async, but a device that stays scriptless is an anomaly the host must surface (not
+    // swallow). Count the render calls that found no registry entry; warn ONCE past the grace window.
+    missingCalls = 0;
+    warnedMissing = false;
+    constructor(uuid, kind, registryName) {
+        this.uuid = uuid;
+        this.kind = kind;
+        this.registryName = registryName;
+    }
+}
+const resolveMapping = (declaration) => {
+    // Mirrors ScriptDeclaration.resolveValueMapping EXACTLY (same lib-std calls), so the bridge maps a param's
+    // automation value identically to the TS engine -> parity is by construction.
+    switch (declaration.mapping) {
+        case "unipolar": return ValueMapping.unipolar();
+        case "linear": return ValueMapping.linear(declaration.min, declaration.max);
+        case "exp": return ValueMapping.exponential(declaration.min, declaration.max);
+        case "int": return ValueMapping.linearInteger(declaration.min, declaration.max);
+        case "bool": return ValueMapping.linearInteger(0, 1);
+        default: return ValueMapping.unipolar();
+    }
+};
+const validateOutput = (channels, s0, s1) => {
+    for (let channel = 0; channel < channels.length; channel++) {
+        const samples = channels[channel];
+        for (let i = s0; i < s1; i++) {
+            const sample = samples[i];
+            if (sample !== sample) {
+                return `NaN detected in output channel ${channel} at sample ${i}`;
+            }
+            if (sample > MAX_AMPLITUDE || sample < -MAX_AMPLITUDE) {
+                return `Signal overflow in channel ${channel} at sample ${i} (amplitude: ${sample.toFixed(1)})`;
+            }
+        }
+    }
+    return null;
+};
+export class ScriptBridges {
+    #memory;
+    #engine;
+    #sampleRate;
+    #onMessage;
+    #bridges = new Map();
+    #byUuid = new Map();
+    #nextHandle = 1;
+    constructor(memory, engine, sampleRate, onMessage = () => { }) {
+        this.#memory = memory;
+        this.#engine = engine;
+        this.#sampleRate = sampleRate;
+        this.#onMessage = onMessage;
+    }
+    /// The `host_script_*` (+ no engine `host_self_uuid`) closures to bind into each scriptable device's `env`.
+    imports() {
+        return {
+            host_script_create: (uuidPtr, kind, statePtr) => this.#create(uuidPtr, kind, statePtr),
+            host_script_audio: (handle, srcL, srcR, outL, outR, s0, s1, index, p0, p1, bpm, flags) => this.#audio(handle, srcL, srcR, outL, outR, s0, s1, index, p0, p1, bpm, flags),
+            host_script_note_on: (handle, pitch, velocity, cent, id) => this.#noteOn(handle, pitch, velocity, cent, id),
+            host_script_note_off: (handle, id) => this.#noteOff(handle, id),
+            host_script_reset: (handle) => this.#reset(handle),
+            host_script_param: (handle, index, kind, value) => this.#param(handle, index, kind, value),
+            host_script_sample: (handle, index, sampleHandle, present) => this.#sample(handle, index, sampleHandle, present),
+            host_script_notes: (handle, inPtr, inCount, outPtr, outMax, from, to, bpm, flags, s0, s1) => this.#notes(handle, inPtr, inCount, outPtr, outMax, from, to, bpm, flags, s0, s1),
+            host_script_release: (handle) => this.#release(handle)
+        };
+    }
+    // A `create` for a uuid that already has a live bridge REPLACES it: release the old one first (its
+    // Processor + limiter + runtime), so a rebind the engine's `terminate` hasn't (yet, or ever) reached for
+    // never orphans the previous bridge — the dedup a bare `#nextHandle++` per call was missing entirely.
+    #create(uuidPtr, kind, _statePtr) {
+        const uuid = UUID.toString(new Uint8Array(this.#memory.buffer, uuidPtr, 16).slice());
+        const existingHandle = this.#byUuid.get(uuid);
+        if (isDefined(existingHandle)) {
+            this.#release(existingHandle);
+        }
+        const handle = this.#nextHandle++;
+        this.#bridges.set(handle, new Bridge(uuid, kind, REGISTRY_BY_KIND[kind] ?? "werkstattProcessors"));
+        this.#byUuid.set(uuid, handle);
+        return handle;
+    }
+    // Poll the registry and hot-swap the user Processor when its `update` changed (the TS #tryLoad/#swapProcessor),
+    // then re-apply the cached params + samples. Returns the live, non-silenced proc, or null.
+    #ensureProc(bridge) {
+        const registry = globalThis.openDAW?.[bridge.registryName]?.[bridge.uuid];
+        if (registry === undefined && bridge.currentUpdate === -1) {
+            // Never loaded and still absent: tolerate the async-load grace window, then report once so a scriptable
+            // device silently muting its chain (the "Open Up renders silent" failure) can never pass unnoticed.
+            if (!bridge.warnedMissing && ++bridge.missingCalls > MISSING_GRACE_CALLS) {
+                bridge.warnedMissing = true;
+                this.#onMessage(bridge.uuid, `No Processor registered at globalThis.openDAW.${bridge.registryName}[${bridge.uuid}] — device is rendering silence`);
+            }
+            return null;
+        }
+        if (registry !== undefined && registry.update !== bridge.currentUpdate) {
+            try {
+                const proc = new registry.create();
+                bridge.paramMappings = new Map(registry.params.map(declaration => [declaration.index, { label: declaration.label, mapping: resolveMapping(declaration) }]));
+                bridge.sampleLabels = new Map(registry.samples.map(declaration => [declaration.index, declaration.label]));
+                if (bridge.kind === KIND_INSTRUMENT) {
+                    proc.samples = {};
+                    for (const label of bridge.sampleLabels.values()) {
+                        proc.samples[label] = null;
+                    }
+                    bridge.limiter ??= new SimpleLimiter(this.#sampleRate);
+                }
+                if (bridge.kind === KIND_MIDI_EFFECT) {
+                    bridge.spielwerk = new SpielwerkRuntime();
+                }
+                bridge.proc = proc;
+                bridge.currentUpdate = registry.update;
+                bridge.silenced = false;
+                // Re-apply the parameters + samples the engine pushed before this swap (re-mapping each raw value
+                // through the new script's @param mapping).
+                for (const [index, raw] of bridge.rawParams) {
+                    this.#applyParam(bridge, index, raw.kind, raw.value);
+                }
+                for (const [index, sampleHandle] of bridge.sampleHandles) {
+                    this.#deliverSample(bridge, index, sampleHandle);
+                }
+            }
+            catch (error) {
+                this.#silence(bridge, `Failed to instantiate Processor: ${error}`);
+            }
+        }
+        return bridge.silenced ? null : bridge.proc;
+    }
+    #audio(handle, srcL, srcR, outL, outR, s0, s1, index, p0, p1, bpm, flags) {
+        const bridge = this.#bridges.get(handle);
+        if (bridge === undefined) {
+            return 1;
+        }
+        const proc = this.#ensureProc(bridge);
+        if (proc === null) {
+            return 1;
+        }
+        const buffer = this.#memory.buffer;
+        const outLeft = new Float32Array(buffer, outL, RENDER_QUANTUM);
+        const outRight = new Float32Array(buffer, outR, RENDER_QUANTUM);
+        const block = { index, p0, p1, s0, s1, bpm, flags };
+        try {
+            if (bridge.kind === KIND_AUDIO_EFFECT) {
+                const io = { src: [new Float32Array(buffer, srcL, RENDER_QUANTUM), new Float32Array(buffer, srcR, RENDER_QUANTUM)], out: [outLeft, outRight] };
+                proc.process(io, block);
+            }
+            else {
+                // Re-resolve the @sample slots every block (mirrors the TS `#pollSamples`): a sample's PCM loads
+                // ASYNC after bind, so the handle is delivered before its frames are resident; re-resolving flips
+                // `samples[label]` from null to the AudioData once ready. Re-deriving the views each block also
+                // keeps them valid if the SharedArrayBuffer grew (same reason `#audio` re-derives its outputs).
+                for (const [sampleIndex, sampleHandle] of bridge.sampleHandles) {
+                    this.#deliverSample(bridge, sampleIndex, sampleHandle);
+                }
+                outLeft.fill(0.0, s0, s1);
+                outRight.fill(0.0, s0, s1);
+                proc.process([outLeft, outRight], block);
+            }
+        }
+        catch (error) {
+            this.#silence(bridge, `Runtime error: ${error}`);
+            return 1;
+        }
+        const error = validateOutput([outLeft, outRight], s0, s1);
+        if (error !== null) {
+            outLeft.fill(0.0, s0, s1);
+            outRight.fill(0.0, s0, s1);
+            this.#silence(bridge, error);
+            return 1;
+        }
+        if (bridge.kind === KIND_INSTRUMENT && bridge.limiter !== null) {
+            // SimpleLimiter.replace only reads `buffer.channels()`; a duck-typed view over our two channels reuses
+            // the exact limiter code (and its persistent envelope) without an intermediate AudioBuffer copy.
+            bridge.limiter.replace({ channels: () => [outLeft, outRight] }, s0, s1);
+        }
+        return 0;
+    }
+    // Notes can arrive BEFORE the first audio block, so ensure the user Processor is loaded here too (the engine
+    // delivers note-on/off, then calls process; the TS processor has the proc loaded before any note).
+    #noteOn(handle, pitch, velocity, cent, id) {
+        const bridge = this.#bridges.get(handle);
+        if (bridge !== undefined) {
+            this.#ensureProc(bridge)?.noteOn?.(pitch, velocity, cent, id);
+        }
+    }
+    #noteOff(handle, id) {
+        const bridge = this.#bridges.get(handle);
+        if (bridge !== undefined) {
+            this.#ensureProc(bridge)?.noteOff?.(id);
+        }
+    }
+    #reset(handle) {
+        const bridge = this.#bridges.get(handle);
+        bridge?.proc?.reset?.();
+        bridge?.spielwerk?.reset();
+    }
+    #param(handle, index, kind, value) {
+        const bridge = this.#bridges.get(handle);
+        if (bridge === undefined) {
+            return;
+        }
+        bridge.rawParams.set(index, { kind, value }); // cache for replay once the proc + mappings exist
+        this.#applyParam(bridge, index, kind, value);
+    }
+    // Map one raw (kind, value) through the param's @param mapping and hand it to the user proc. A no-op when the
+    // proc / mappings are not loaded yet — `#ensureProc` replays `rawParams` once they are.
+    #applyParam(bridge, index, kind, value) {
+        const entry = bridge.paramMappings.get(index);
+        if (entry === undefined) {
+            return;
+        }
+        const mapped = kind === PARAM_KIND_UNIT ? entry.mapping.y(value) : value;
+        bridge.proc?.paramChanged?.(entry.label, mapped);
+    }
+    // The engine's sample handles are 0-based slot indices, so 0 is a VALID handle; `present` is the absence
+    // signal. Cache -1 when no sample so `#deliverSample` can tell "handle 0, resolved" from "no sample".
+    #sample(handle, index, sampleHandle, present) {
+        const bridge = this.#bridges.get(handle);
+        if (bridge === undefined) {
+            return;
+        }
+        const resolved = present !== 0 ? sampleHandle : -1;
+        bridge.sampleHandles.set(index, resolved);
+        this.#deliverSample(bridge, index, resolved);
+    }
+    #notes(handle, inPtr, inCount, outPtr, outMax, from, to, bpm, flags, s0, s1) {
+        const bridge = this.#bridges.get(handle);
+        if (bridge === undefined) {
+            return 0;
+        }
+        const proc = this.#ensureProc(bridge);
+        if (proc === null || bridge.spielwerk === null) {
+            return 0;
+        }
+        try {
+            return runSpielwerk(bridge.spielwerk, proc, this.#memory.buffer, inPtr, inCount, outPtr, outMax, from, to, bpm, flags, s0, s1);
+        }
+        catch (error) {
+            this.#silence(bridge, `Runtime error: ${error}`);
+            return 0;
+        }
+    }
+    // Resolve a sample handle's resident planar frames and hand the user proc an AudioData view (no copy).
+    #deliverSample(bridge, index, sampleHandle) {
+        if (bridge.proc === null) {
+            return;
+        }
+        const label = bridge.sampleLabels.get(index);
+        if (label === undefined) {
+            return;
+        }
+        if (sampleHandle < 0) {
+            bridge.proc.samples[label] = null;
+            return;
+        }
+        const scratch = this.#engine.input_reserve(16);
+        if (this.#engine.host_resolve_sample(sampleHandle, scratch) === 0) {
+            bridge.proc.samples[label] = null;
+            return;
+        }
+        const view = new DataView(this.#memory.buffer, scratch, 16);
+        const framesPtr = view.getUint32(0, true);
+        const frameCount = view.getUint32(4, true);
+        const channelCount = view.getUint32(8, true);
+        const sampleRate = view.getFloat32(12, true);
+        const frames = [];
+        for (let channel = 0; channel < channelCount; channel++) {
+            frames.push(new Float32Array(this.#memory.buffer, framesPtr + channel * frameCount * 4, frameCount));
+        }
+        bridge.proc.samples[label] = { sampleRate, numberOfFrames: frameCount, numberOfChannels: channelCount, frames };
+    }
+    #silence(bridge, message) {
+        bridge.silenced = true;
+        this.#onMessage(bridge.uuid, message);
+    }
+    // THIS device's instance is dying (a genuine removal, never a chain-edit survivor, called from the
+    // engine's `terminate` export — or a `#create` dedup replacing a stale bridge for the same uuid): drop
+    // the bridge (its Processor + limiter + runtime are then just garbage-collected JS objects).
+    #release(handle) {
+        const bridge = this.#bridges.get(handle);
+        if (!isDefined(bridge)) {
+            return;
+        }
+        this.#bridges.delete(handle);
+        if (this.#byUuid.get(bridge.uuid) === handle) {
+            this.#byUuid.delete(bridge.uuid);
+        }
+    }
+    /// Test-only introspection: how many bridges are currently live, proving a rebind's `#create` dedup
+    /// released the previous one instead of orphaning it.
+    liveBridgeCount() {
+        return this.#bridges.size;
+    }
+}

package/dist/script-spielwerk.d.ts

@@ -0,0 +1,24 @@
+type ScheduledNote = {
+    position: number;
+    duration: number;
+    pitch: number;
+    velocity: number;
+    cent: number;
+};
+type RetainedNote = {
+    id: number;
+    position: number;
+    duration: number;
+    pitch: number;
+    velocity: number;
+    cent: number;
+};
+export declare class SpielwerkRuntime {
+    readonly retained: RetainedNote[];
+    readonly scheduled: ScheduledNote[];
+    readonly sourceToOutput: Map<number, Set<number>>;
+    reset(): void;
+}
+export declare const runSpielwerk: (runtime: SpielwerkRuntime, proc: any, memory: ArrayBufferLike, inPtr: number, inCount: number, outPtr: number, outMax: number, from: number, to: number, bpm: number, flags: number, s0: number, s1: number) => number;
+export {};
+//# sourceMappingURL=script-spielwerk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"script-spielwerk.d.ts","sourceRoot":"","sources":["../src/script-spielwerk.ts"],"names":[],"mappings":"AAgBA,KAAK,aAAa,GAAG;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAA;AACxG,KAAK,YAAY,GAAG;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAA;AAKnH,qBAAa,gBAAgB;IACzB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,CAAK;IACtC,QAAQ,CAAC,SAAS,EAAE,aAAa,EAAE,CAAK;IACxC,QAAQ,CAAC,cAAc,2BAAiC;IAExD,KAAK,IAAI,IAAI;CAKhB;AA6BD,eAAO,MAAM,YAAY,GAAI,SAAS,gBAAgB,EAAE,MAAM,GAAG,EAAE,QAAQ,eAAe,EAC7D,OAAO,MAAM,EAAE,SAAS,MAAM,EAAE,QAAQ,MAAM,EAAE,QAAQ,MAAM,EAC9D,MAAM,MAAM,EAAE,IAAI,MAAM,EAAE,KAAK,MAAM,EAAE,OAAO,MAAM,EAAE,IAAI,MAAM,EAAE,IAAI,MAAM,KAAG,MA0F3G,CAAA"}

package/dist/script-spielwerk.js

@@ -0,0 +1,179 @@
+// Spielwerk's stateful note-transform orchestration (mirrors the TS `SpielwerkDeviceProcessor.processNotes`),
+// run JS-side by the script bridge. It reads the upstream input `EventRecord`s the device pulled (note-on /
+// note-off), builds the `UserEvent` stream, runs the user generator `*process(block, events)`, validates each
+// yielded note, schedules future-block notes, and correlates note-on -> note-off via a retainer so it can emit
+// the stops. The persistent state (retainer + scheduler) lives in `SpielwerkRuntime` across blocks.
+//
+// EventRecord (abi, 40 bytes, little-endian): position f64@0, offset u32@8, kind u32@12, id u32@16,
+// pitch u32@20, velocity f32@24, cent f32@28, duration f64@32. kind: 0 = note-on, 1 = note-off. `duration` is
+// the note's pulse length, carried on the note-on so the user script's `event.duration` is exact.
+const RECORD_SIZE = 40;
+const KIND_NOTE_ON = 0;
+const KIND_NOTE_OFF = 1;
+const MAX_NOTES_PER_BLOCK = 128;
+const MAX_SCHEDULED_NOTES = 128;
+let nextOutputId = 1;
+// One Spielwerk instance's cross-block state.
+export class SpielwerkRuntime {
+    retained = []; // emitted notes awaiting their note-off (position + duration reached)
+    scheduled = []; // notes the script placed in a future block
+    sourceToOutput = new Map(); // upstream note-on id -> emitted output ids it spawned
+    reset() {
+        this.retained.length = 0;
+        this.scheduled.length = 0;
+        this.sourceToOutput.clear();
+    }
+}
+const writeRecord = (view, slot, kind, position, id, pitch, velocity, cent, duration) => {
+    const base = slot * RECORD_SIZE;
+    view.setFloat64(base + 0, position, true);
+    view.setUint32(base + 8, 0, true); // offset: a midi-fx leaves it for the consumer to resolve from `position`
+    view.setUint32(base + 12, kind, true);
+    view.setUint32(base + 16, id, true);
+    view.setUint32(base + 20, pitch, true);
+    view.setFloat32(base + 24, velocity, true);
+    view.setFloat32(base + 28, cent, true);
+    view.setFloat64(base + 32, duration, true);
+};
+const validateNote = (note, from) => {
+    if (note === undefined || note === null) {
+        return "process yielded undefined";
+    }
+    if (typeof note.pitch !== "number" || note.pitch !== note.pitch) {
+        return `Invalid pitch: ${note.pitch}`;
+    }
+    if (note.pitch < 0 || note.pitch > 127) {
+        return `Pitch out of range: ${note.pitch} (must be 0-127)`;
+    }
+    if (typeof note.velocity !== "number" || note.velocity !== note.velocity) {
+        return `Invalid velocity: ${note.velocity}`;
+    }
+    if (note.velocity < 0 || note.velocity > 1) {
+        return `Velocity out of range: ${note.velocity} (must be 0-1)`;
+    }
+    if (typeof note.duration !== "number" || note.duration !== note.duration) {
+        return `Invalid duration: ${note.duration}`;
+    }
+    if (note.duration <= 0) {
+        return `Duration must be positive: ${note.duration}`;
+    }
+    if (typeof note.position !== "number" || note.position !== note.position) {
+        return `Invalid position: ${note.position}`;
+    }
+    if (note.position < from) {
+        return `Position ${note.position} is in the past (block starts at ${from})`;
+    }
+    return null;
+};
+// Run one pulled range through the user generator + tracking, writing output records, returning the count.
+// Throws on a script error / validation failure / flood (the bridge catches it and silences).
+export const runSpielwerk = (runtime, proc, memory, inPtr, inCount, outPtr, outMax, from, to, bpm, flags, s0, s1) => {
+    const input = new DataView(memory, inPtr, inCount * RECORD_SIZE);
+    const out = new DataView(memory, outPtr, outMax * RECORD_SIZE);
+    let outCount = 0;
+    const emit = (kind, position, id, pitch, velocity, cent, duration) => {
+        if (outCount >= outMax) {
+            throw new Error(`Note flood: exceeded ${outMax} output notes per range`);
+        }
+        writeRecord(out, outCount++, kind, position, id, pitch, velocity, cent, duration);
+    };
+    // Release retained notes whose span completed within this range, emitting their note-off.
+    for (let i = runtime.retained.length - 1; i >= 0; i--) {
+        const note = runtime.retained[i];
+        const end = note.position + note.duration;
+        if (end < to) {
+            runtime.retained.splice(i, 1);
+            emit(KIND_NOTE_OFF, end, note.id, note.pitch, 0, 0, 0);
+        }
+    }
+    // Build the upstream UserEvent stream; a note-off cancels the outputs its source note-on spawned.
+    const events = [];
+    for (let i = 0; i < inCount; i++) {
+        const base = i * RECORD_SIZE;
+        const kind = input.getUint32(base + 12, true);
+        const id = input.getUint32(base + 16, true);
+        const position = input.getFloat64(base + 0, true);
+        const pitch = input.getUint32(base + 20, true);
+        if (kind === KIND_NOTE_ON) {
+            events.push({ gate: true, id, position, duration: input.getFloat64(base + 32, true), pitch, velocity: input.getFloat32(base + 24, true), cent: input.getFloat32(base + 28, true) });
+        }
+        else if (kind === KIND_NOTE_OFF) {
+            const outputs = runtime.sourceToOutput.get(id);
+            if (outputs !== undefined) {
+                for (const outputId of outputs) {
+                    const index = runtime.retained.findIndex(note => note.id === outputId);
+                    if (index >= 0) {
+                        const note = runtime.retained.splice(index, 1)[0];
+                        emit(KIND_NOTE_OFF, position, note.id, note.pitch, 0, 0, 0);
+                    }
+                }
+                runtime.sourceToOutput.delete(id);
+            }
+            events.push({ gate: false, id, position, pitch });
+        }
+    }
+    // Replay any scheduled notes that fall in this range.
+    for (let i = runtime.scheduled.length - 1; i >= 0; i--) {
+        const note = runtime.scheduled[i];
+        if (note.position >= from && note.position < to) {
+            runtime.scheduled.splice(i, 1);
+            emit(KIND_NOTE_ON, note.position, retain(runtime, note), note.pitch, note.velocity, note.cent, note.duration);
+        }
+    }
+    // Run the user generator, tracking the current source note-on id (so emitted notes correlate for note-off).
+    let currentSourceId = -1;
+    const tracked = {
+        [Symbol.iterator]() {
+            let index = 0;
+            return {
+                next() {
+                    if (index >= events.length) {
+                        currentSourceId = -1;
+                        return { done: true, value: undefined };
+                    }
+                    const value = events[index++];
+                    if (value.gate) {
+                        currentSourceId = value.id;
+                    }
+                    return { done: false, value };
+                }
+            };
+        }
+    };
+    const block = { from, to, bpm, s0, s1, flags };
+    let noteCount = 0;
+    for (const yielded of proc.process(block, tracked)) {
+        if (++noteCount > MAX_NOTES_PER_BLOCK) {
+            throw new Error(`Note flood: exceeded ${MAX_NOTES_PER_BLOCK} notes per block`);
+        }
+        const error = validateNote(yielded, from);
+        if (error !== null) {
+            throw new Error(error);
+        }
+        const note = { position: yielded.position, duration: yielded.duration, pitch: yielded.pitch, velocity: yielded.velocity, cent: yielded.cent ?? 0 };
+        if (note.position >= to) {
+            if (runtime.scheduled.length >= MAX_SCHEDULED_NOTES) {
+                throw new Error(`Scheduler full: exceeded ${MAX_SCHEDULED_NOTES} scheduled notes`);
+            }
+            runtime.scheduled.push(note);
+        }
+        else {
+            const id = retain(runtime, note);
+            if (currentSourceId >= 0) {
+                let set = runtime.sourceToOutput.get(currentSourceId);
+                if (set === undefined) {
+                    set = new Set();
+                    runtime.sourceToOutput.set(currentSourceId, set);
+                }
+                set.add(id);
+            }
+            emit(KIND_NOTE_ON, note.position, id, note.pitch, note.velocity, note.cent, note.duration);
+        }
+    }
+    return outCount;
+};
+const retain = (runtime, note) => {
+    const id = nextOutputId++;
+    runtime.retained.push({ id, position: note.position, duration: note.duration, pitch: note.pitch, velocity: note.velocity, cent: note.cent });
+    return id;
+};

package/dist/soundfont-simplify.d.ts

@@ -0,0 +1,28 @@
+import type { SoundFont2 } from "soundfont2";
+export type SimpleSample = {
+    pcm: Float32Array;
+    sampleRate: number;
+    loopStart: number;
+    loopEnd: number;
+};
+export type SimpleRegion = {
+    keyLo: number;
+    keyHi: number;
+    velLo: number;
+    velHi: number;
+    sampleIndex: number;
+    rootKey: number;
+    loopMode: number;
+    pan: number;
+    attack: number;
+    decay: number;
+    sustain: number;
+    release: number;
+};
+export type SimpleSoundfont = {
+    samples: ReadonlyArray<SimpleSample>;
+    presets: ReadonlyArray<ReadonlyArray<SimpleRegion>>;
+};
+export declare const encodeSoundfont: ({ samples, presets }: SimpleSoundfont) => ArrayBuffer;
+export declare const simplifySoundfont: (soundfont: SoundFont2) => ArrayBuffer;
+//# sourceMappingURL=soundfont-simplify.d.ts.map

package/dist/soundfont-simplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soundfont-simplify.d.ts","sourceRoot":"","sources":["../src/soundfont-simplify.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAA;AAqB1C,MAAM,MAAM,YAAY,GAAG;IACvB,GAAG,EAAE,YAAY,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC1D,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAClE,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC1B,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;IACpC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CAAA;CACtD,CAAA;AAUD,eAAO,MAAM,eAAe,GAAI,sBAAoB,eAAe,KAAG,WAqDrE,CAAA;AAYD,eAAO,MAAM,iBAAiB,GAAI,WAAW,UAAU,KAAG,WA6CzD,CAAA"}