@marmooo/soundfont-split 0.0.2 → 0.0.3

package/esm/cli.js

@@ -3,7 +3,7 @@ import "./_dnt.polyfills.js";
 import * as dntShim from "./_dnt.shims.js";
 import { parseArgs } from "./deps/jsr.io/@std/cli/1.0.32/mod.js";
 import { splitSoundFont } from "./src/mod.js";
-const VERSION = "0.0.2";
+const VERSION = "0.0.3";
 const args = parseArgs(dntShim.Deno.args, {
     string: ["quality", "concurrency"],
     boolean: ["version", "help", "recompress"],

package/esm/src/split.js

@@ -1,5 +1,5 @@
 import * as dntShim from "../_dnt.shims.js";
-import { Bag, GeneratorList, Instrument, ModulatorList, parse, PresetHeader, RangeValue, SampleHeader, SoundFont, write, } from "@marmooo/soundfont";
+import { AudioData, Bag, GeneratorList, Instrument, ModulatorList, parse, PresetHeader, RangeValue, SampleHeader, SoundFont, write, } from "@marmooo/soundfont";
 import { createDefaultEncoder } from "@marmooo/sf3-codec/encoder";
 import { createDefaultDecoder } from "@marmooo/sf3-codec/decoder";
 function cloneGenerator(g) {
@@ -22,6 +22,68 @@ function defaultConcurrency() {
     const nav = dntShim.dntGlobalThis.navigator;
     return nav?.hardwareConcurrency ?? 4;
 }
+// Collect sample IDs referenced by a preset (including stereo-linked
+// partners). Uses only headers / zones / generators — does NOT touch the
+// lazy `samples` array, so it never materializes AudioData.
+function collectSampleIds(soundFont, presetHeaderIndex) {
+    const headers = soundFont.presetHeaders;
+    if (presetHeaderIndex < 0 ||
+        presetHeaderIndex >= headers.length ||
+        headers[presetHeaderIndex].isEnd) {
+        throw new Error(`invalid presetHeaderIndex: ${presetHeaderIndex}`);
+    }
+    const ph = headers[presetHeaderIndex];
+    const nextPh = headers[presetHeaderIndex + 1];
+    const bagFrom = ph.presetBagIndex;
+    const bagTo = nextPh
+        ? nextPh.presetBagIndex
+        : soundFont.presetZone.length - 1;
+    const instrumentIdSet = new Set();
+    for (let zi = bagFrom; zi < bagTo; zi++) {
+        const bag = soundFont.presetZone[zi];
+        const nextBag = soundFont.presetZone[zi + 1];
+        if (!nextBag)
+            break;
+        const gens = soundFont.presetGenerators.slice(bag.generatorIndex, nextBag.generatorIndex);
+        for (const g of gens) {
+            if (g.type === "instrument" && typeof g.value === "number") {
+                instrumentIdSet.add(g.value);
+            }
+        }
+    }
+    const sampleIdSet = new Set();
+    for (const oldInstId of instrumentIdSet) {
+        const inst = soundFont.instruments[oldInstId];
+        const nextInst = soundFont.instruments[oldInstId + 1];
+        const iBagFrom = inst.instrumentBagIndex;
+        const iBagTo = nextInst
+            ? nextInst.instrumentBagIndex
+            : soundFont.instrumentZone.length - 1;
+        for (let zi = iBagFrom; zi < iBagTo; zi++) {
+            const bag = soundFont.instrumentZone[zi];
+            const nextBag = soundFont.instrumentZone[zi + 1];
+            if (!nextBag)
+                break;
+            const gens = soundFont.instrumentGenerators.slice(bag.generatorIndex, nextBag.generatorIndex);
+            for (const g of gens) {
+                if (g.type === "sampleID" && typeof g.value === "number") {
+                    const sh = soundFont.sampleHeaders[g.value];
+                    if (!sh || sh.isEnd)
+                        continue;
+                    sampleIdSet.add(g.value);
+                    const linked = soundFont.sampleHeaders[sh.sampleLink];
+                    if (sh.sampleLink !== 0 && linked && !linked.isEnd) {
+                        sampleIdSet.add(sh.sampleLink);
+                    }
+                }
+            }
+        }
+    }
+    return [...sampleIdSet].filter((id) => {
+        const sh = soundFont.sampleHeaders[id];
+        return sh !== undefined && !sh.isEnd;
+    });
+}
 // Extract a single preset (by index into soundFont.presetHeaders) into a
 // minimal SoundFont that contains only the instruments and samples that
 // preset depends on. Indices are remapped so the result is a valid
@@ -122,9 +184,16 @@ export function extractPreset(soundFont, presetHeaderIndex) {
                 .map(cloneModulator);
             for (const g of gens) {
                 if (g.type === "sampleID" && typeof g.value === "number") {
-                    sampleIdSet.add(g.value);
                     const sh = soundFont.sampleHeaders[g.value];
-                    if (sh && sh.sampleLink !== 0 && !sh.isEnd) {
+                    // Skip terminal / out-of-range sample IDs (can appear after
+                    // empty-name terminal records are stripped by the parser).
+                    if (!sh || sh.isEnd)
+                        continue;
+                    sampleIdSet.add(g.value);
+                    const linked = soundFont.sampleHeaders[sh.sampleLink];
+                    if (sh.sampleLink !== 0 &&
+                        linked &&
+                        !linked.isEnd) {
                         sampleIdSet.add(sh.sampleLink);
                     }
                 }
@@ -145,14 +214,19 @@ export function extractPreset(soundFont, presetHeaderIndex) {
         !instrumentGenerators[instrumentGenerators.length - 1].isEnd) {
         instrumentGenerators.push(GeneratorList.end());
     }
-    const sampleIds = [...sampleIdSet].sort((a, b) => a - b);
+    const sampleIds = [...sampleIdSet]
+        .filter((id) => {
+        const sh = soundFont.sampleHeaders[id];
+        return sh !== undefined && !sh.isEnd;
+    })
+        .sort((a, b) => a - b);
     const sampleMap = new Map();
     sampleIds.forEach((id, i) => sampleMap.set(id, i));
     for (const g of instrumentGenerators) {
         if (g.type === "sampleID" && typeof g.value === "number") {
             const mapped = sampleMap.get(g.value);
             if (mapped === undefined) {
-                throw new Error(`sample ${g.value} not collected`);
+                throw new Error(`sample ${g.value} not collected (missing or terminal header)`);
             }
             g.value = mapped;
         }
@@ -162,11 +236,17 @@ export function extractPreset(soundFont, presetHeaderIndex) {
     for (const oldId of sampleIds) {
         const sh = soundFont.sampleHeaders[oldId];
         const sample = soundFont.samples[oldId];
+        if (!sh || !sample || sh.isEnd)
+            continue;
         const newLink = sh.sampleLink !== 0 && sampleMap.has(sh.sampleLink)
             ? sampleMap.get(sh.sampleLink)
             : 0;
-        sampleHeaders.push(new SampleHeader(sh.sampleName, sh.start, sh.end, sh.loopStart, sh.loopEnd, sh.sampleRate, sh.originalPitch, sh.pitchCorrection, newLink, sh.sampleType));
-        samples.push(sample);
+        const newHeader = new SampleHeader(sh.sampleName, sh.start, sh.end, sh.loopStart, sh.loopEnd, sh.sampleRate, sh.originalPitch, sh.pitchCorrection, newLink, sh.sampleType);
+        sampleHeaders.push(newHeader);
+        // Copy sample bytes into a standalone buffer so the extracted SoundFont
+        // does not keep a view into the source file. After write() we can drop
+        // these copies without waiting for the source soundFont to release.
+        samples.push(new AudioData(sample.type, newHeader, sample.data.slice()));
     }
     const newPh = new PresetHeader(ph.presetName, ph.preset, ph.bank, 0, ph.library, ph.genre, ph.morphology);
     return new SoundFont({
@@ -191,17 +271,23 @@ export function extractPreset(soundFont, presetHeaderIndex) {
 // pool sized by `options.concurrency` (so the budget is global, not
 // per-preset).
 export async function splitSoundFont(input, outDir, options = {}) {
-    const bytes = typeof input === "string" ? dntShim.Deno.readFileSync(input) : input;
+    // Keep a mutable reference so we can drop the original file buffer after
+    // all presets have been extracted (samples are lazy views into this buffer).
+    let bytes = typeof input === "string"
+        ? dntShim.Deno.readFileSync(input)
+        : input;
     const soundFont = parse(bytes);
     const toSf3 = options.toSf3 !== false;
     const concurrency = Math.max(1, options.concurrency ?? defaultConcurrency());
     await dntShim.Deno.mkdir(outDir, { recursive: true });
-    // Shared encoder pool for the whole job. Callers that supply their own
-    // encode via sf2ToSf3 are not used here - we own the pool so we can dispose
-    // it and let the process exit (workers otherwise keep the event loop alive).
+    // Encoder/decoder pools. WASM heaps inside workers tend to grow and not
+    // return memory to the OS, so we periodically dispose + recreate them
+    // (see recycleCodecs below).
     let encode;
     let decode;
-    if (toSf3) {
+    const makeCodecs = () => {
+        if (!toSf3)
+            return;
         encode = createDefaultEncoder({
             quality: options.quality,
             poolSize: concurrency,
@@ -209,57 +295,115 @@ export async function splitSoundFont(input, outDir, options = {}) {
         if (options.recompress) {
             decode = createDefaultDecoder({ poolSize: concurrency });
         }
-    }
+    };
+    const disposeCodecs = () => {
+        encode?.dispose?.();
+        decode?.dispose?.();
+        encode = undefined;
+        decode = undefined;
+    };
+    makeCodecs();
+    // Recycle WASM worker pools every N finished presets to bound native/WASM
+    // heap growth. 16 is a balance between recycle cost and memory creep.
+    const RECYCLE_EVERY = 16;
+    let finishedSinceRecycle = 0;
     try {
         const headers = soundFont.presetHeaders;
         const jobs = [];
         for (let i = 0; i < headers.length; i++) {
-            if (!headers[i].isEnd)
-                jobs.push({ index: i, ph: headers[i] });
+            if (!headers[i].isEnd) {
+                jobs.push({
+                    index: i,
+                    ph: headers[i],
+                    // Structure-only scan: does not materialize AudioData.
+                    sampleIds: collectSampleIds(soundFont, i),
+                });
+            }
+        }
+        // How many remaining presets still need each sample. When the count
+        // hits 0 after a preset is written, we drop that slot from the source
+        // soundFont so the lazy AudioData (and its view into the file buffer)
+        // can be collected.
+        const sampleRefCount = new Map();
+        for (const job of jobs) {
+            for (const id of job.sampleIds) {
+                sampleRefCount.set(id, (sampleRefCount.get(id) ?? 0) + 1);
+            }
         }
-        // Cap how many presets we assemble at once (encode pool is the real
-        // limiter; this just bounds peak memory from parallel write()s).
-        const presetParallel = concurrency;
+        // Only one preset is assembled/written at a time. Sample encodes inside
+        // write() still run up to `concurrency` in parallel. Parallel presets
+        // multiplied peak memory (several full encoded SF3 buffers in flight)
+        // and made WASM heap growth much worse; sequential presets keep the
+        // high-water mark close to "source file + one preset's temps".
         const results = new Array(jobs.length);
-        let nextJob = 0;
-        const runWorker = async () => {
-            while (true) {
-                const jobIndex = nextJob++;
-                if (jobIndex >= jobs.length)
-                    return;
-                const { index, ph } = jobs[jobIndex];
-                const extracted = extractPreset(soundFont, index);
-                const bankDir = `${outDir}/${String(ph.bank).padStart(3, "0")}`;
-                await dntShim.Deno.mkdir(bankDir, { recursive: true });
-                const ext = toSf3 ? "sf3" : "sf2";
-                const fileName = `${String(ph.preset).padStart(3, "0")}.${ext}`;
-                const path = `${bankDir}/${fileName}`;
-                const outBytes = toSf3
-                    ? await write(extracted, {
-                        // write() may schedule many encodes; the pool caps actual work.
-                        encode: encode,
-                        decode,
-                        concurrency,
-                    })
-                    : await write(extracted);
-                dntShim.Deno.writeFileSync(path, outBytes);
-                const presetName = ph.presetName.replace(/\0+$/, "").trim();
-                results[jobIndex] = {
-                    bank: ph.bank,
-                    preset: ph.preset,
-                    presetName,
-                    path,
-                    byteLength: outBytes.byteLength,
-                };
-                console.log(`wrote ${path} (${outBytes.byteLength} bytes) - ${presetName}`);
+        for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
+            const { index, ph, sampleIds } = jobs[jobIndex];
+            const extracted = extractPreset(soundFont, index);
+            const bankDir = `${outDir}/${String(ph.bank).padStart(3, "0")}`;
+            await dntShim.Deno.mkdir(bankDir, { recursive: true });
+            const ext = toSf3 ? "sf3" : "sf2";
+            const fileName = `${String(ph.preset).padStart(3, "0")}.${ext}`;
+            const path = `${bankDir}/${fileName}`;
+            const outBytes = toSf3
+                ? await write(extracted, {
+                    encode: encode,
+                    decode,
+                    concurrency,
+                })
+                : await write(extracted);
+            dntShim.Deno.writeFileSync(path, outBytes);
+            const presetName = ph.presetName.replace(/\0+$/, "").trim();
+            results[jobIndex] = {
+                bank: ph.bank,
+                preset: ph.preset,
+                presetName,
+                path,
+                byteLength: outBytes.byteLength,
+            };
+            console.log(`wrote ${path} (${outBytes.byteLength} bytes) - ${presetName}`);
+            // Drop extracted copies (independent ArrayBuffers from extractPreset).
+            for (const s of extracted.samples) {
+                // Break any remaining internal refs early.
+                s.data = new Uint8Array(0);
+            }
+            extracted.samples.length = 0;
+            extracted.sampleHeaders.length = 0;
+            // Release source samples that no remaining preset needs.
+            for (const id of sampleIds) {
+                const left = (sampleRefCount.get(id) ?? 1) - 1;
+                if (left <= 0) {
+                    sampleRefCount.delete(id);
+                    const slot = soundFont.samples[id];
+                    if (slot) {
+                        // Detach the view into the source file buffer before dropping
+                        // the AudioData object.
+                        slot.data = new Uint8Array(0);
+                    }
+                    delete soundFont.samples[id];
+                }
+                else {
+                    sampleRefCount.set(id, left);
+                }
+            }
+            finishedSinceRecycle++;
+            if (toSf3 && finishedSinceRecycle >= RECYCLE_EVERY) {
+                disposeCodecs();
+                makeCodecs();
+                finishedSinceRecycle = 0;
             }
-        };
-        const workers = Array.from({ length: Math.min(presetParallel, jobs.length) }, () => runWorker());
-        await Promise.all(workers);
+        }
+        // Safety net: clear anything left and drop the original file buffer.
+        for (let i = 0; i < soundFont.samples.length; i++) {
+            const s = soundFont.samples[i];
+            if (s)
+                s.data = new Uint8Array(0);
+        }
+        soundFont.samples.length = 0;
+        soundFont.sampleHeaders.length = 0;
+        bytes = null;
         return results;
     }
     finally {
-        encode?.dispose?.();
-        decode?.dispose?.();
+        disposeCodecs();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marmooo/soundfont-split",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Split a SoundFont (SF2 / SF3) into per-preset SF3 files.",
   "repository": {
     "type": "git",

package/script/src/split.js

@@ -59,6 +59,68 @@ function defaultConcurrency() {
     const nav = dntShim.dntGlobalThis.navigator;
     return nav?.hardwareConcurrency ?? 4;
 }
+// Collect sample IDs referenced by a preset (including stereo-linked
+// partners). Uses only headers / zones / generators — does NOT touch the
+// lazy `samples` array, so it never materializes AudioData.
+function collectSampleIds(soundFont, presetHeaderIndex) {
+    const headers = soundFont.presetHeaders;
+    if (presetHeaderIndex < 0 ||
+        presetHeaderIndex >= headers.length ||
+        headers[presetHeaderIndex].isEnd) {
+        throw new Error(`invalid presetHeaderIndex: ${presetHeaderIndex}`);
+    }
+    const ph = headers[presetHeaderIndex];
+    const nextPh = headers[presetHeaderIndex + 1];
+    const bagFrom = ph.presetBagIndex;
+    const bagTo = nextPh
+        ? nextPh.presetBagIndex
+        : soundFont.presetZone.length - 1;
+    const instrumentIdSet = new Set();
+    for (let zi = bagFrom; zi < bagTo; zi++) {
+        const bag = soundFont.presetZone[zi];
+        const nextBag = soundFont.presetZone[zi + 1];
+        if (!nextBag)
+            break;
+        const gens = soundFont.presetGenerators.slice(bag.generatorIndex, nextBag.generatorIndex);
+        for (const g of gens) {
+            if (g.type === "instrument" && typeof g.value === "number") {
+                instrumentIdSet.add(g.value);
+            }
+        }
+    }
+    const sampleIdSet = new Set();
+    for (const oldInstId of instrumentIdSet) {
+        const inst = soundFont.instruments[oldInstId];
+        const nextInst = soundFont.instruments[oldInstId + 1];
+        const iBagFrom = inst.instrumentBagIndex;
+        const iBagTo = nextInst
+            ? nextInst.instrumentBagIndex
+            : soundFont.instrumentZone.length - 1;
+        for (let zi = iBagFrom; zi < iBagTo; zi++) {
+            const bag = soundFont.instrumentZone[zi];
+            const nextBag = soundFont.instrumentZone[zi + 1];
+            if (!nextBag)
+                break;
+            const gens = soundFont.instrumentGenerators.slice(bag.generatorIndex, nextBag.generatorIndex);
+            for (const g of gens) {
+                if (g.type === "sampleID" && typeof g.value === "number") {
+                    const sh = soundFont.sampleHeaders[g.value];
+                    if (!sh || sh.isEnd)
+                        continue;
+                    sampleIdSet.add(g.value);
+                    const linked = soundFont.sampleHeaders[sh.sampleLink];
+                    if (sh.sampleLink !== 0 && linked && !linked.isEnd) {
+                        sampleIdSet.add(sh.sampleLink);
+                    }
+                }
+            }
+        }
+    }
+    return [...sampleIdSet].filter((id) => {
+        const sh = soundFont.sampleHeaders[id];
+        return sh !== undefined && !sh.isEnd;
+    });
+}
 // Extract a single preset (by index into soundFont.presetHeaders) into a
 // minimal SoundFont that contains only the instruments and samples that
 // preset depends on. Indices are remapped so the result is a valid
@@ -159,9 +221,16 @@ function extractPreset(soundFont, presetHeaderIndex) {
                 .map(cloneModulator);
             for (const g of gens) {
                 if (g.type === "sampleID" && typeof g.value === "number") {
-                    sampleIdSet.add(g.value);
                     const sh = soundFont.sampleHeaders[g.value];
-                    if (sh && sh.sampleLink !== 0 && !sh.isEnd) {
+                    // Skip terminal / out-of-range sample IDs (can appear after
+                    // empty-name terminal records are stripped by the parser).
+                    if (!sh || sh.isEnd)
+                        continue;
+                    sampleIdSet.add(g.value);
+                    const linked = soundFont.sampleHeaders[sh.sampleLink];
+                    if (sh.sampleLink !== 0 &&
+                        linked &&
+                        !linked.isEnd) {
                         sampleIdSet.add(sh.sampleLink);
                     }
                 }
@@ -182,14 +251,19 @@ function extractPreset(soundFont, presetHeaderIndex) {
         !instrumentGenerators[instrumentGenerators.length - 1].isEnd) {
         instrumentGenerators.push(soundfont_1.GeneratorList.end());
     }
-    const sampleIds = [...sampleIdSet].sort((a, b) => a - b);
+    const sampleIds = [...sampleIdSet]
+        .filter((id) => {
+        const sh = soundFont.sampleHeaders[id];
+        return sh !== undefined && !sh.isEnd;
+    })
+        .sort((a, b) => a - b);
     const sampleMap = new Map();
     sampleIds.forEach((id, i) => sampleMap.set(id, i));
     for (const g of instrumentGenerators) {
         if (g.type === "sampleID" && typeof g.value === "number") {
             const mapped = sampleMap.get(g.value);
             if (mapped === undefined) {
-                throw new Error(`sample ${g.value} not collected`);
+                throw new Error(`sample ${g.value} not collected (missing or terminal header)`);
             }
             g.value = mapped;
         }
@@ -199,11 +273,17 @@ function extractPreset(soundFont, presetHeaderIndex) {
     for (const oldId of sampleIds) {
         const sh = soundFont.sampleHeaders[oldId];
         const sample = soundFont.samples[oldId];
+        if (!sh || !sample || sh.isEnd)
+            continue;
         const newLink = sh.sampleLink !== 0 && sampleMap.has(sh.sampleLink)
             ? sampleMap.get(sh.sampleLink)
             : 0;
-        sampleHeaders.push(new soundfont_1.SampleHeader(sh.sampleName, sh.start, sh.end, sh.loopStart, sh.loopEnd, sh.sampleRate, sh.originalPitch, sh.pitchCorrection, newLink, sh.sampleType));
-        samples.push(sample);
+        const newHeader = new soundfont_1.SampleHeader(sh.sampleName, sh.start, sh.end, sh.loopStart, sh.loopEnd, sh.sampleRate, sh.originalPitch, sh.pitchCorrection, newLink, sh.sampleType);
+        sampleHeaders.push(newHeader);
+        // Copy sample bytes into a standalone buffer so the extracted SoundFont
+        // does not keep a view into the source file. After write() we can drop
+        // these copies without waiting for the source soundFont to release.
+        samples.push(new soundfont_1.AudioData(sample.type, newHeader, sample.data.slice()));
     }
     const newPh = new soundfont_1.PresetHeader(ph.presetName, ph.preset, ph.bank, 0, ph.library, ph.genre, ph.morphology);
     return new soundfont_1.SoundFont({
@@ -228,17 +308,23 @@ function extractPreset(soundFont, presetHeaderIndex) {
 // pool sized by `options.concurrency` (so the budget is global, not
 // per-preset).
 async function splitSoundFont(input, outDir, options = {}) {
-    const bytes = typeof input === "string" ? dntShim.Deno.readFileSync(input) : input;
+    // Keep a mutable reference so we can drop the original file buffer after
+    // all presets have been extracted (samples are lazy views into this buffer).
+    let bytes = typeof input === "string"
+        ? dntShim.Deno.readFileSync(input)
+        : input;
     const soundFont = (0, soundfont_1.parse)(bytes);
     const toSf3 = options.toSf3 !== false;
     const concurrency = Math.max(1, options.concurrency ?? defaultConcurrency());
     await dntShim.Deno.mkdir(outDir, { recursive: true });
-    // Shared encoder pool for the whole job. Callers that supply their own
-    // encode via sf2ToSf3 are not used here - we own the pool so we can dispose
-    // it and let the process exit (workers otherwise keep the event loop alive).
+    // Encoder/decoder pools. WASM heaps inside workers tend to grow and not
+    // return memory to the OS, so we periodically dispose + recreate them
+    // (see recycleCodecs below).
     let encode;
     let decode;
-    if (toSf3) {
+    const makeCodecs = () => {
+        if (!toSf3)
+            return;
         encode = (0, encoder_1.createDefaultEncoder)({
             quality: options.quality,
             poolSize: concurrency,
@@ -246,57 +332,115 @@ async function splitSoundFont(input, outDir, options = {}) {
         if (options.recompress) {
             decode = (0, decoder_1.createDefaultDecoder)({ poolSize: concurrency });
         }
-    }
+    };
+    const disposeCodecs = () => {
+        encode?.dispose?.();
+        decode?.dispose?.();
+        encode = undefined;
+        decode = undefined;
+    };
+    makeCodecs();
+    // Recycle WASM worker pools every N finished presets to bound native/WASM
+    // heap growth. 16 is a balance between recycle cost and memory creep.
+    const RECYCLE_EVERY = 16;
+    let finishedSinceRecycle = 0;
     try {
         const headers = soundFont.presetHeaders;
         const jobs = [];
         for (let i = 0; i < headers.length; i++) {
-            if (!headers[i].isEnd)
-                jobs.push({ index: i, ph: headers[i] });
+            if (!headers[i].isEnd) {
+                jobs.push({
+                    index: i,
+                    ph: headers[i],
+                    // Structure-only scan: does not materialize AudioData.
+                    sampleIds: collectSampleIds(soundFont, i),
+                });
+            }
         }
-        // Cap how many presets we assemble at once (encode pool is the real
-        // limiter; this just bounds peak memory from parallel write()s).
-        const presetParallel = concurrency;
+        // How many remaining presets still need each sample. When the count
+        // hits 0 after a preset is written, we drop that slot from the source
+        // soundFont so the lazy AudioData (and its view into the file buffer)
+        // can be collected.
+        const sampleRefCount = new Map();
+        for (const job of jobs) {
+            for (const id of job.sampleIds) {
+                sampleRefCount.set(id, (sampleRefCount.get(id) ?? 0) + 1);
+            }
+        }
+        // Only one preset is assembled/written at a time. Sample encodes inside
+        // write() still run up to `concurrency` in parallel. Parallel presets
+        // multiplied peak memory (several full encoded SF3 buffers in flight)
+        // and made WASM heap growth much worse; sequential presets keep the
+        // high-water mark close to "source file + one preset's temps".
         const results = new Array(jobs.length);
-        let nextJob = 0;
-        const runWorker = async () => {
-            while (true) {
-                const jobIndex = nextJob++;
-                if (jobIndex >= jobs.length)
-                    return;
-                const { index, ph } = jobs[jobIndex];
-                const extracted = extractPreset(soundFont, index);
-                const bankDir = `${outDir}/${String(ph.bank).padStart(3, "0")}`;
-                await dntShim.Deno.mkdir(bankDir, { recursive: true });
-                const ext = toSf3 ? "sf3" : "sf2";
-                const fileName = `${String(ph.preset).padStart(3, "0")}.${ext}`;
-                const path = `${bankDir}/${fileName}`;
-                const outBytes = toSf3
-                    ? await (0, soundfont_1.write)(extracted, {
-                        // write() may schedule many encodes; the pool caps actual work.
-                        encode: encode,
-                        decode,
-                        concurrency,
-                    })
-                    : await (0, soundfont_1.write)(extracted);
-                dntShim.Deno.writeFileSync(path, outBytes);
-                const presetName = ph.presetName.replace(/\0+$/, "").trim();
-                results[jobIndex] = {
-                    bank: ph.bank,
-                    preset: ph.preset,
-                    presetName,
-                    path,
-                    byteLength: outBytes.byteLength,
-                };
-                console.log(`wrote ${path} (${outBytes.byteLength} bytes) - ${presetName}`);
+        for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
+            const { index, ph, sampleIds } = jobs[jobIndex];
+            const extracted = extractPreset(soundFont, index);
+            const bankDir = `${outDir}/${String(ph.bank).padStart(3, "0")}`;
+            await dntShim.Deno.mkdir(bankDir, { recursive: true });
+            const ext = toSf3 ? "sf3" : "sf2";
+            const fileName = `${String(ph.preset).padStart(3, "0")}.${ext}`;
+            const path = `${bankDir}/${fileName}`;
+            const outBytes = toSf3
+                ? await (0, soundfont_1.write)(extracted, {
+                    encode: encode,
+                    decode,
+                    concurrency,
+                })
+                : await (0, soundfont_1.write)(extracted);
+            dntShim.Deno.writeFileSync(path, outBytes);
+            const presetName = ph.presetName.replace(/\0+$/, "").trim();
+            results[jobIndex] = {
+                bank: ph.bank,
+                preset: ph.preset,
+                presetName,
+                path,
+                byteLength: outBytes.byteLength,
+            };
+            console.log(`wrote ${path} (${outBytes.byteLength} bytes) - ${presetName}`);
+            // Drop extracted copies (independent ArrayBuffers from extractPreset).
+            for (const s of extracted.samples) {
+                // Break any remaining internal refs early.
+                s.data = new Uint8Array(0);
             }
-        };
-        const workers = Array.from({ length: Math.min(presetParallel, jobs.length) }, () => runWorker());
-        await Promise.all(workers);
+            extracted.samples.length = 0;
+            extracted.sampleHeaders.length = 0;
+            // Release source samples that no remaining preset needs.
+            for (const id of sampleIds) {
+                const left = (sampleRefCount.get(id) ?? 1) - 1;
+                if (left <= 0) {
+                    sampleRefCount.delete(id);
+                    const slot = soundFont.samples[id];
+                    if (slot) {
+                        // Detach the view into the source file buffer before dropping
+                        // the AudioData object.
+                        slot.data = new Uint8Array(0);
+                    }
+                    delete soundFont.samples[id];
+                }
+                else {
+                    sampleRefCount.set(id, left);
+                }
+            }
+            finishedSinceRecycle++;
+            if (toSf3 && finishedSinceRecycle >= RECYCLE_EVERY) {
+                disposeCodecs();
+                makeCodecs();
+                finishedSinceRecycle = 0;
+            }
+        }
+        // Safety net: clear anything left and drop the original file buffer.
+        for (let i = 0; i < soundFont.samples.length; i++) {
+            const s = soundFont.samples[i];
+            if (s)
+                s.data = new Uint8Array(0);
+        }
+        soundFont.samples.length = 0;
+        soundFont.sampleHeaders.length = 0;
+        bytes = null;
         return results;
     }
     finally {
-        encode?.dispose?.();
-        decode?.dispose?.();
+        disposeCodecs();
     }
 }