@opendaw/studio-core-wasm 0.0.2

package/dist/soundfont-simplify.js

@@ -0,0 +1,143 @@
+// Builds the SIMPLIFIED soundfont BLOB the wasm engine consumes (see crates/stock-devices/device-soundfont/
+// src/blob.rs — the format is a WASM CONTRACT mirrored on both sides). The main thread keeps the parsed SF2;
+// this flattens it into a compact, directly-indexable structure so the wasm never parses SF2/RIFF.
+//
+// `encodeSoundfont` serializes a plain description (samples + per-preset regions) into the blob. `simplify-
+// Soundfont` walks a parsed `SoundFont2` into that description, resolving every SF2 generator EXACTLY as the TS
+// `SoundfontVoice` does: preset-zone × instrument-zone flattening, instrument-overrides-preset precedence,
+// timecent→seconds envelope conversion, sustain 1−x/1000, root-key/loop/pan resolution.
+// SF2 generator IDs (spec-fixed), the only ones the TS `SoundfontVoice` honors. Inlined to avoid a brittle
+// cross-package deep import; they are a frozen contract.
+const GeneratorType = {
+    Pan: 17,
+    AttackVolEnv: 34,
+    DecayVolEnv: 36,
+    SustainVolEnv: 37,
+    ReleaseVolEnv: 38,
+    KeyRange: 43,
+    VelRange: 44,
+    CoarseTune: 51,
+    FineTune: 52,
+    SampleId: 53,
+    SampleModes: 54,
+    OverridingRootKey: 58
+};
+// ---- Binary layout (mirrors blob.rs) -----------------------------------------------------------------------
+const MAGIC = 0x4F53_4632; // "OSF2"
+const HEADER_BYTES = 32;
+const SAMPLE_STRIDE = 24;
+const REGION_STRIDE = 40;
+const PRESET_STRIDE = 8;
+export const encodeSoundfont = ({ samples, presets }) => {
+    const regionCount = presets.reduce((sum, regions) => sum + regions.length, 0);
+    const samplesOff = HEADER_BYTES;
+    const regionsOff = samplesOff + samples.length * SAMPLE_STRIDE;
+    const presetsOff = regionsOff + regionCount * REGION_STRIDE;
+    const pcmOff = presetsOff + presets.length * PRESET_STRIDE;
+    const pcmFrames = samples.reduce((sum, sample) => sum + sample.pcm.length, 0);
+    const buffer = new ArrayBuffer(pcmOff + pcmFrames * 4);
+    const view = new DataView(buffer);
+    view.setUint32(0, MAGIC, true);
+    view.setUint32(4, 1, true); // version
+    view.setUint32(8, samples.length, true);
+    view.setUint32(12, regionCount, true);
+    view.setUint32(16, presets.length, true);
+    view.setUint32(20, samplesOff, true);
+    view.setUint32(24, regionsOff, true);
+    view.setUint32(28, presetsOff, true);
+    // Sample table + PCM (concatenated planes).
+    let pcmCursor = pcmOff;
+    samples.forEach((sample, index) => {
+        const base = samplesOff + index * SAMPLE_STRIDE;
+        view.setUint32(base, pcmCursor, true);
+        view.setUint32(base + 4, sample.pcm.length, true);
+        view.setFloat32(base + 8, sample.sampleRate, true);
+        view.setUint32(base + 12, sample.loopStart, true);
+        view.setUint32(base + 16, sample.loopEnd, true);
+        new Float32Array(buffer, pcmCursor, sample.pcm.length).set(sample.pcm);
+        pcmCursor += sample.pcm.length * 4;
+    });
+    // Region table (all presets flattened) + preset table (each preset's [start, count) range).
+    let regionCursor = 0;
+    presets.forEach((regions, presetIndex) => {
+        const presetBase = presetsOff + presetIndex * PRESET_STRIDE;
+        view.setUint32(presetBase, regionCursor, true);
+        view.setUint32(presetBase + 4, regions.length, true);
+        for (const region of regions) {
+            const base = regionsOff + regionCursor * REGION_STRIDE;
+            view.setUint8(base, region.keyLo);
+            view.setUint8(base + 1, region.keyHi);
+            view.setUint8(base + 2, region.velLo);
+            view.setUint8(base + 3, region.velHi);
+            view.setUint32(base + 4, region.sampleIndex, true);
+            view.setUint32(base + 8, region.rootKey, true);
+            view.setUint32(base + 12, region.loopMode, true);
+            view.setFloat32(base + 16, region.pan, true);
+            view.setFloat32(base + 20, region.attack, true);
+            view.setFloat32(base + 24, region.decay, true);
+            view.setFloat32(base + 28, region.sustain, true);
+            view.setFloat32(base + 32, region.release, true);
+            regionCursor++;
+        }
+    });
+    return buffer;
+};
+const numeric = (zone, type) => zone.generators[type]?.value;
+// instrument-overrides-preset, matching TS `getCombinedGenerator`.
+const combined = (preset, inst, type) => numeric(inst, type) ?? numeric(preset, type);
+const timecentsToSeconds = (value) => value !== undefined ? Math.pow(2.0, value / 1200.0) : 0.005;
+const rangeOf = (zone, type) => zone.generators[type]?.range ?? { lo: 0, hi: 127 };
+export const simplifySoundfont = (soundfont) => {
+    const samples = [];
+    const sampleIndexByRef = new Map();
+    const internSample = (sample) => {
+        const existing = sampleIndexByRef.get(sample);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const pcm = new Float32Array(sample.data.length);
+        for (let i = 0; i < pcm.length; i++) {
+            pcm[i] = sample.data[i] / 32768.0;
+        }
+        const index = samples.length;
+        samples.push({ pcm, sampleRate: sample.header.sampleRate, loopStart: sample.header.startLoop, loopEnd: sample.header.endLoop });
+        sampleIndexByRef.set(sample, index);
+        return index;
+    };
+    const presets = soundfont.presets.map(preset => {
+        const regions = [];
+        for (const presetZone of preset.zones) {
+            const presetKey = rangeOf(presetZone, GeneratorType.KeyRange);
+            const presetVel = rangeOf(presetZone, GeneratorType.VelRange);
+            for (const instZone of presetZone.instrument.zones) {
+                const instKey = rangeOf(instZone, GeneratorType.KeyRange);
+                const instVel = rangeOf(instZone, GeneratorType.VelRange);
+                // A note matches iff it is inside BOTH zones' ranges (TS tests each independently) = the intersection.
+                const keyLo = Math.max(presetKey.lo, instKey.lo), keyHi = Math.min(presetKey.hi, instKey.hi);
+                const velLo = Math.max(presetVel.lo, instVel.lo), velHi = Math.min(presetVel.hi, instVel.hi);
+                if (keyLo > keyHi || velLo > velHi) {
+                    continue;
+                } // empty intersection: unreachable, drop it
+                const sample = instZone.sample ?? soundfont.samples[numeric(instZone, GeneratorType.SampleId) ?? 0];
+                if (sample === undefined) {
+                    continue;
+                }
+                const sampleIndex = internSample(sample);
+                const rootKey = numeric(instZone, GeneratorType.OverridingRootKey) ?? sample.header.originalPitch ?? 60;
+                const sampleModes = combined(presetZone, instZone, GeneratorType.SampleModes) ?? 0;
+                const sustain = combined(presetZone, instZone, GeneratorType.SustainVolEnv);
+                regions.push({
+                    keyLo, keyHi, velLo, velHi, sampleIndex, rootKey,
+                    loopMode: sampleModes === 1 || sampleModes === 3 ? 1 : 0,
+                    pan: (combined(presetZone, instZone, GeneratorType.Pan) ?? 0) / 1000.0,
+                    attack: timecentsToSeconds(combined(presetZone, instZone, GeneratorType.AttackVolEnv)),
+                    decay: timecentsToSeconds(combined(presetZone, instZone, GeneratorType.DecayVolEnv)),
+                    sustain: 1.0 - (sustain ?? 0.0) / 1000.0,
+                    release: timecentsToSeconds(combined(presetZone, instZone, GeneratorType.ReleaseVolEnv))
+                });
+            }
+        }
+        return regions;
+    });
+    return encodeSoundfont({ samples, presets });
+};

package/dist/sync/loopback.d.ts

@@ -0,0 +1,8 @@
+import { Terminable } from "@opendaw/lib-std";
+import { Messenger } from "@opendaw/lib-runtime";
+export type SyncLoopback = {
+    source: Messenger;
+    target: Messenger;
+} & Terminable;
+export declare const createSyncLoopback: () => SyncLoopback;
+//# sourceMappingURL=loopback.d.ts.map

package/dist/sync/loopback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopback.d.ts","sourceRoot":"","sources":["../../src/sync/loopback.ts"],"names":[],"mappings":"AAIA,OAAO,EAA0C,UAAU,EAAC,MAAM,kBAAkB,CAAA;AACpF,OAAO,EAAC,SAAS,EAAC,MAAM,sBAAsB,CAAA;AAE9C,MAAM,MAAM,YAAY,GAAG;IAAC,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAC,GAAG,UAAU,CAAA;AAE9E,eAAO,MAAM,kBAAkB,QAAO,YAiBrC,CAAA"}

package/dist/sync/loopback.js

@@ -0,0 +1,23 @@
+// A synchronous in-process Messenger pair: `send` on one side delivers to the other side's subscribers
+// within the SAME call stack. SyncSource's update tasks must be serialized AT emission time — a
+// MessageChannel loopback defers by a macrotask, letting a later transaction delete boxes before the
+// earlier batch resolves its primitive-field codecs against the live source graph.
+import { Notifier, panic } from "@opendaw/lib-std";
+export const createSyncLoopback = () => {
+    const toTarget = new Notifier();
+    const toSource = new Notifier();
+    const port = (outgoing, incoming) => ({
+        send: (message) => outgoing.notify(message),
+        channel: () => panic("the sync loopback has no channels"),
+        subscribe: (observer) => incoming.subscribe(observer),
+        terminate: () => { }
+    });
+    return {
+        source: port(toTarget, toSource),
+        target: port(toSource, toTarget),
+        terminate: () => {
+            toTarget.terminate();
+            toSource.terminate();
+        }
+    };
+};

package/dist/sync/serialize-update-tasks.d.ts

@@ -0,0 +1,4 @@
+import { BoxGraph, UpdateTask } from "@opendaw/lib-box";
+import { BoxIO } from "@opendaw/studio-boxes";
+export declare const serializeUpdateTasks: (tasks: ReadonlyArray<UpdateTask<BoxIO.TypeMap>>, source: BoxGraph<BoxIO.TypeMap>) => ArrayBuffer;
+//# sourceMappingURL=serialize-update-tasks.d.ts.map

package/dist/sync/serialize-update-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-update-tasks.d.ts","sourceRoot":"","sources":["../../src/sync/serialize-update-tasks.ts"],"names":[],"mappings":"AAKA,OAAO,EAAU,QAAQ,EAAmC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAC/F,OAAO,EAAC,KAAK,EAAC,MAAM,uBAAuB,CAAA;AAE3C,eAAO,MAAM,oBAAoB,GAC7B,OAAO,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,EAC/C,QAAQ,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,KAAG,WA8BrC,CAAA"}

package/dist/sync/serialize-update-tasks.js

@@ -0,0 +1,40 @@
+// Serialize SyncSource's forward-only UpdateTask[] into the byte stream the Rust engine's
+// decode_forward consumes. Primitive value types are resolved from the source graph's schema, so
+// this must run where that graph lives (the main thread), not in the wasm-only worklet.
+import { ByteArrayOutput, isDefined, UUID } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+export const serializeUpdateTasks = (tasks, source) => {
+    const output = ByteArrayOutput.create();
+    output.writeInt(tasks.length);
+    tasks.forEach(task => {
+        output.writeString(task.type);
+        if (task.type === "new") {
+            UUID.toDataOutput(output, task.uuid);
+            output.writeString(task.name);
+            output.writeInt(task.buffer.byteLength);
+            output.writeBytes(new Int8Array(task.buffer));
+        }
+        else if (task.type === "update-primitive") {
+            const address = Address.reconstruct(task.address);
+            address.write(output);
+            const field = source.findVertex(address).unwrap(() => `no field at ${address}`);
+            const serialization = field.serialization();
+            output.writeString(serialization.type);
+            serialization.encode(output, task.value);
+        }
+        else if (task.type === "update-pointer") {
+            Address.reconstruct(task.address).write(output);
+            if (isDefined(task.target)) {
+                output.writeBoolean(true);
+                Address.reconstruct(task.target).write(output);
+            }
+            else {
+                output.writeBoolean(false);
+            }
+        }
+        else if (task.type === "delete") {
+            UUID.toDataOutput(output, task.uuid);
+        }
+    });
+    return output.toArrayBuffer();
+};

package/dist/utf8.d.ts

@@ -0,0 +1,2 @@
+export declare const decodeUtf8: (bytes: Uint8Array) => string;
+//# sourceMappingURL=utf8.d.ts.map

package/dist/utf8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../src/utf8.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,GAAI,OAAO,UAAU,KAAG,MAc9C,CAAA"}

package/dist/utf8.js

@@ -0,0 +1,19 @@
+// Decode UTF-8 bytes WITHOUT TextDecoder: the AudioWorkletGlobalScope provides neither TextDecoder nor
+// TextEncoder (see worklet-scope.ts), so constructing one anywhere worklet-reachable kills the module
+// before `registerProcessor` runs. Shared by every worklet host that reads a string out of wasm memory
+// (panic messages, MIDI device ids). Malformed sequences decode as U+FFFD; a truncated tail reads zeros.
+export const decodeUtf8 = (bytes) => {
+    let result = "";
+    let index = 0;
+    const next = () => (bytes[index++] ?? 0) & 0x3F;
+    while (index < bytes.length) {
+        const byte0 = bytes[index++] ?? 0;
+        const codePoint = byte0 < 0x80 ? byte0
+            : (byte0 & 0xE0) === 0xC0 ? ((byte0 & 0x1F) << 6) | next()
+                : (byte0 & 0xF0) === 0xE0 ? ((byte0 & 0x0F) << 12) | (next() << 6) | next()
+                    : (byte0 & 0xF8) === 0xF0 ? ((byte0 & 0x07) << 18) | (next() << 12) | (next() << 6) | next()
+                        : 0xFFFD;
+        result += codePoint <= 0x10FFFF ? String.fromCodePoint(codePoint) : "�";
+    }
+    return result;
+};