@buffered-audio/nodes 0.18.0 → 0.18.2

package/dist/cli.js

@@ -39,21 +39,26 @@ function parseParams(entries) {
   }
   return Object.fromEntries(parameters);
 }
+function stamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
 function createEventSink() {
   const totals = /* @__PURE__ */ new Map();
   const subscribe = (events) => {
     events.on("started", (node) => {
-      process.stdout.write(`[${labelOf(node)}] started
+      process.stdout.write(`${stamp()} [${labelOf(node)}] started
 `);
     });
     events.on("progress", (node, payload) => {
       const label = labelOf(node);
       if (payload.framesTotal !== void 0) {
         const percent = Math.round(payload.framesDone / payload.framesTotal * 100);
-        process.stdout.write(`[${label}] ${payload.phase} ${percent}%
+        process.stdout.write(`${stamp()} [${label}] ${payload.phase} ${percent}%
 `);
       } else {
-        process.stdout.write(`[${label}] ${payload.phase} frames=${payload.framesDone}
+        process.stdout.write(`${stamp()} [${label}] ${payload.phase} frames=${payload.framesDone}
 `);
       }
     });
@@ -61,12 +66,13 @@ function createEventSink() {
       const data = payload.data ? Object.entries(payload.data).map(([key, value]) => `${key}=${String(value)}`) : [];
       const parts = [payload.message, ...data].join(" ");
       const prefix = payload.level === "warn" ? "warn: " : "";
-      process.stdout.write(`${prefix}[${labelOf(node)}] ${parts}
+      process.stdout.write(`${stamp()} ${prefix}[${labelOf(node)}] ${parts}
 `);
     });
     events.on("finished", (node, payload) => {
       totals.set(node, { framesDone: payload.framesDone, processingMs: payload.processingMs });
-      process.stdout.write(`[${labelOf(node)}] finished
+      const ms = payload.processingMs !== void 0 ? ` ms=${Math.round(payload.processingMs)}` : "";
+      process.stdout.write(`${stamp()} [${labelOf(node)}] finished frames=${payload.framesDone}${ms}
 `);
     });
   };
@@ -74,10 +80,10 @@ function createEventSink() {
     for (const [node, { framesDone, processingMs }] of totals) {
       const label = labelOf(node);
       if (processingMs !== void 0) {
-        process.stdout.write(`[${label}] processed ${framesDone} frames in ${Math.round(processingMs)}ms
+        process.stdout.write(`${stamp()} [${label}] processed ${framesDone} frames in ${Math.round(processingMs)}ms
 `);
       } else {
-        process.stdout.write(`[${label}] processed ${framesDone} frames
+        process.stdout.write(`${stamp()} [${label}] processed ${framesDone} frames
 `);
       }
     }
@@ -85,7 +91,7 @@ function createEventSink() {
       const timing = job.timing;
       if (!timing) continue;
       const label = sourceLabel(job) ?? "source";
-      process.stdout.write(`[${label}] total ${(timing.totalMs / 1e3).toFixed(1)}s, ${timing.realTimeMultiplier.toFixed(1)}x RT
+      process.stdout.write(`${stamp()} [${label}] total ${(timing.totalMs / 1e3).toFixed(1)}s, ${timing.realTimeMultiplier.toFixed(1)}x RT
 `);
     }
   };

package/dist/index.js

@@ -29629,6 +29629,7 @@ BufferedAudioNode.nodeDescription = "";
 BufferedAudioNode.schema = external_exports2.object({});
 var UNKNOWN_TOTAL_QUANTUM_FRAMES = 48e4;
 var DEFAULT_PROGRESS_QUANTUM = 0.1;
+var PROCESS_QUANTUM_FRACTION = 0.02;
 var BufferedStream = class {
   constructor(node) {
     this.quantumFraction = DEFAULT_PROGRESS_QUANTUM;
@@ -29656,7 +29657,8 @@ var BufferedStream = class {
       this.renderEvents.emit("progress", this.identity, { phase: phase2, framesDone, framesTotal: total });
       return;
     }
-    const quantum = total ? Math.max(1, Math.floor(total * this.quantumFraction)) : UNKNOWN_TOTAL_QUANTUM_FRAMES;
+    const fraction = phase2 === "process" ? Math.min(this.quantumFraction, PROCESS_QUANTUM_FRACTION) : this.quantumFraction;
+    const quantum = total ? Math.max(1, Math.floor(total * fraction)) : UNKNOWN_TOTAL_QUANTUM_FRAMES;
     const boundary = Math.floor(framesDone / quantum) * quantum;
     const last = this.lastBoundaryByPhase.get(phase2);
     if (last !== void 0 && boundary <= last) return;
@@ -29733,7 +29735,7 @@ var BufferedTransformStream = class extends BufferedStream {
         controller.enqueue(block);
       }
       this.framesEmitted += frames;
-      this.emitProgress("emit", this.framesEmitted);
+      this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames);
     };
   }
   async handleTransform(block, controller) {
@@ -29777,7 +29779,7 @@ var BufferedTransformStream = class extends BufferedStream {
     const start = performance.now();
     const wholeFile = this.blockSize === WHOLE_FILE;
     await this.buffer.flushWrites();
-    if (wholeFile) this.emitProgress("process", 0, void 0, { force: true });
+    if (wholeFile) this.emitProgress("process", 0, framesBefore, { force: true });
     await this.transform(this.buffer, this.makeEnqueue(controller));
     if (wholeFile) this.emitProgress("process", framesBefore, framesBefore, { force: true });
     await this.buffer.clear();
@@ -29793,7 +29795,7 @@ var BufferedTransformStream = class extends BufferedStream {
       await this.fireTransform(controller);
     }
     await this.flush(this.makeEnqueue(controller));
-    this.emitProgress("emit", this.framesEmitted, void 0, { force: true });
+    this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames, { force: true });
     this.emitFinished({ framesDone: this.framesBuffered, processingMs: this.processingMs });
   }
   async destroy() {
@@ -29822,6 +29824,7 @@ var BufferedSourceStream = class extends BufferedStream {
   constructor() {
     super(...arguments);
     this.framesRead = 0;
+    this.processingMs = 0;
     this.hasStarted = false;
   }
   setup(context) {
@@ -29831,6 +29834,7 @@ var BufferedSourceStream = class extends BufferedStream {
   async _setup(context) {
     let done = false;
     this.framesRead = 0;
+    this.processingMs = 0;
     this.hasStarted = false;
     const { signal, durationFrames: sourceTotalFrames, highWaterMark } = context;
     return new ReadableStream(
@@ -29848,11 +29852,13 @@ var BufferedSourceStream = class extends BufferedStream {
               this.hasStarted = true;
               this.emitStarted();
             }
+            const start = performance.now();
             const chunk = await this._read();
+            this.processingMs += performance.now() - start;
             if (!chunk) {
               done = true;
               this.emitProgress("read", this.framesRead, sourceTotalFrames, { force: true });
-              this.emitFinished({ framesDone: this.framesRead });
+              this.emitFinished({ framesDone: this.framesRead, processingMs: this.processingMs });
               await this.destroy();
               controller.close();
               return;
@@ -29892,6 +29898,7 @@ var BufferedTargetStream = class extends BufferedStream {
     super(...arguments);
     this.hasStarted = false;
     this.framesWritten = 0;
+    this.processingMs = 0;
   }
   setup(readable, context) {
     this.sourceTotalFrames = context.durationFrames;
@@ -29903,20 +29910,25 @@ var BufferedTargetStream = class extends BufferedStream {
   createWritableStream() {
     this.hasStarted = false;
     this.framesWritten = 0;
+    this.processingMs = 0;
     return new WritableStream({
       write: async (chunk) => {
         if (!this.hasStarted) {
           this.hasStarted = true;
           this.emitStarted();
         }
+        const start = performance.now();
         await this._write(chunk);
+        this.processingMs += performance.now() - start;
         this.framesWritten += chunk.samples[0]?.length ?? 0;
         this.emitProgress("write", this.framesWritten, this.sourceTotalFrames);
       },
       close: async () => {
+        const start = performance.now();
         await this._close();
+        this.processingMs += performance.now() - start;
         this.emitProgress("write", this.framesWritten, this.sourceTotalFrames, { force: true });
-        this.emitFinished({ framesDone: this.framesWritten });
+        this.emitFinished({ framesDone: this.framesWritten, processingMs: this.processingMs });
         await this.destroy();
       },
       abort: async () => {
@@ -29957,7 +29969,7 @@ var UnbufferedTransformStream = class extends BufferedStream {
     return (block) => {
       controller.enqueue(block);
       this.framesEmitted += block.samples[0]?.length ?? 0;
-      this.emitProgress("emit", this.framesEmitted);
+      this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames);
     };
   }
   async handleTransform(block, controller) {
@@ -29976,7 +29988,7 @@ var UnbufferedTransformStream = class extends BufferedStream {
     await this.flush(this.makeEnqueue(controller));
     this.processingMs += performance.now() - start;
     this.emitProgress("buffer", this.framesBuffered, this.sourceTotalFrames, { force: true });
-    this.emitProgress("emit", this.framesEmitted, void 0, { force: true });
+    this.emitProgress("emit", this.framesEmitted, this.sourceTotalFrames, { force: true });
     this.emitFinished({ framesDone: this.framesBuffered, processingMs: this.processingMs });
     await this.destroy();
   }
@@ -32172,7 +32184,7 @@ function applyNlmSmoothing(mask, numFrames, numBins, nlmOptions, output) {
 // package.json
 var package_default = {
   name: "@buffered-audio/nodes",
-  version: "0.18.0"};
+  version: "0.18.2"};
 
 // src/package-metadata.ts
 var PACKAGE_NAME = package_default.name;
@@ -33645,6 +33657,7 @@ var NormalizeStream = class extends BufferedTransformStream {
   async transform(buffered, enqueue) {
     const raw = this.peak === 0 ? 1 : this.properties.ceiling / this.peak;
     const scale = Number.isFinite(raw) ? raw : 1;
+    this.log("peak measured", { peak: this.peak, scale, ceiling: this.properties.ceiling });
     for await (const block of buffered.iterate(44100)) {
       if (scale === 1) {
         enqueue(block);
@@ -34804,7 +34817,8 @@ async function iterateForTargets(args) {
     maxAttempts = DEFAULT_MAX_ATTEMPTS,
     tolerance = DEFAULT_TOLERANCE,
     peakTolerance,
-    seedB
+    seedB,
+    onAttempt
   } = args;
   const channelCount = buffer.channels;
   const frames = buffer.frames;
@@ -34893,7 +34907,7 @@ async function iterateForTargets(args) {
       const measured = await measureAttemptOutput({ source: buffer, sampleRate, channelCount, gSmoothed: activeRef });
       const lufsErr = measured.outputLufs - targetLufs;
       const peakErr = measured.outputTruePeakDb - effectiveTargetTp;
-      attempts.push({
+      const attempt = {
         boost: currentBoost,
         limitDb: currentLimit,
         lufsErr,
@@ -34903,7 +34917,9 @@ async function iterateForTargets(args) {
         peakGainDb: currentPeakGainDb,
         peakErr,
         elapsedMs: Date.now() - tAttempt0
-      });
+      };
+      attempts.push(attempt);
+      onAttempt?.(attempt, attemptIdx);
       const lufsScoreTerm = Math.abs(lufsErr) / tolerance;
       const peakScoreTerm = skipPeak ? 0 : Math.abs(peakErr) / peakTolerance;
       const score = Math.max(lufsScoreTerm, peakScoreTerm);
@@ -35510,7 +35526,19 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
       tolerance,
       peakTolerance,
       seedB,
-      detectionEnvelope
+      detectionEnvelope,
+      onAttempt: (attempt, attemptIndex) => {
+        this.log("attempt", {
+          attempt: attemptIndex + 1,
+          B: attempt.boost,
+          peakGainDb: attempt.peakGainDb,
+          lufsErr: attempt.lufsErr,
+          peakErr: attempt.peakErr,
+          outputLra: attempt.outputLra,
+          elapsedMs: attempt.elapsedMs
+        });
+        this.progress(attemptIndex + 1, maxAttempts);
+      }
     });
     this.learnTimingMs.iteration = Date.now() - tIterate0;
     this.learnTimingMs.detection = result.detectionCacheBuildMs;
@@ -35537,20 +35565,6 @@ var LoudnessTargetStream = class extends BufferedTransformStream {
     }
     const limitDbRepr = `${bestLimitDbRepr} (${limitDbSource})`;
     const expansiveGeometry = result.bestPeakGainDb > result.bestB;
-    for (let attemptIdx = 0; attemptIdx < result.attempts.length; attemptIdx++) {
-      const attempt = result.attempts[attemptIdx];
-      if (attempt === void 0) continue;
-      this.log("attempt", {
-        attempt: attemptIdx + 1,
-        B: attempt.boost,
-        peakGainDb: attempt.peakGainDb,
-        lufsErr: attempt.lufsErr,
-        peakErr: attempt.peakErr,
-        outputLra: attempt.outputLra,
-        elapsedMs: attempt.elapsedMs
-      });
-      this.progress(attemptIdx + 1, maxAttempts);
-    }
     const fmt = (x) => x === void 0 ? "off" : String(x);
     this.log("iteration", {
       attempts: result.attempts.length,
@@ -35690,6 +35704,7 @@ var LoudnessNormalizeStream = class extends BufferedTransformStream {
   async transform(buffered, enqueue) {
     const integrated = this.accumulator === void 0 ? -Infinity : this.accumulator.finalize();
     const gain2 = Number.isFinite(integrated) ? Math.pow(10, (this.properties.target - integrated) / 20) : 1;
+    this.log("loudness measured", { integrated, gain: gain2, target: this.properties.target });
     for await (const block of buffered.iterate(44100)) {
       if (gain2 === 1) {
         enqueue(block);
@@ -36258,7 +36273,7 @@ var TruePeakArgmaxAccumulator = class {
     return { db: linearToDb(this.runningMax), peakInputSample: this.peakInputSample };
   }
 };
-async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addonOptions, search) {
+async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addonOptions, search, progress) {
   const channelCount = buffer.channels;
   const signalLength = buffer.frames;
   const order = LATTICE_ORDER;
@@ -36364,6 +36379,7 @@ async function streamLatticeTrajectory(buffer, frameSize, hopSize, backend, addo
       }
     }
     toRead -= got;
+    progress?.(nextFrame, frameCount);
   }
   for (let frame = 0; frame < frameCount; frame++) {
     const wasReached = baseRows[frame] !== void 0;
@@ -36472,16 +36488,18 @@ var CrestReduceStream = class extends BufferedTransformStream {
       peakInputSample,
       sampleRate,
       lambda
-    });
+    }, (done, total) => this.progress(done, total));
     if (frameCount === 0) {
       for await (const block of buffered.iterate(44100)) {
         enqueue(block);
       }
       return;
     }
+    this.log("trajectory analysed", { frameCount });
     const smoothedTrajectory = smoothControlTrajectory(trajectory, smoothing, trajectoryFrameRate(sampleRate, hopSize), exactHoldHalfWidthFrames(sampleRate, hopSize), hopSize);
     await buffered.reset();
     let applyState;
+    let appliedFrames = 0;
     for await (const block of buffered.iterate(44100)) {
       const frames = block.samples[0]?.length ?? 0;
       const blockChannelCount = block.samples.length;
@@ -36493,6 +36511,8 @@ var CrestReduceStream = class extends BufferedTransformStream {
       const transformed = applyState.apply(block.samples, frames);
       const samples = block.samples.map((inputChannel, ch) => transformed[ch] ?? inputChannel);
       enqueue({ samples, offset: block.offset, sampleRate: block.sampleRate, bitDepth: block.bitDepth });
+      appliedFrames += frames;
+      this.progress(Math.min(appliedFrames, totalFrames), totalFrames);
     }
   }
 };
@@ -37218,6 +37238,7 @@ var DeBleedStream = class extends BufferedTransformStream {
     const _twarm = _profStart();
     const seedsByChannel = await this.warmupSeedsAllChannels(buffered, channels, warmupFrames, fftSize, hopSize);
     _profAdd("warmup", _twarm);
+    this.log("warm-up seed complete", { warmupSeconds: WARMUP_SECONDS });
     await buffered.reset();
     for (const refBuffer of referenceBuffers) await refBuffer.reset();
     const kalmanStatesByCh = seedsByChannel.map((seeds) => seeds.map((seed) => createKalmanState(numBins, seed)));
@@ -37414,6 +37435,7 @@ var DeBleedStream = class extends BufferedTransformStream {
         const _twrite = _profStart();
         await outputBuffer.write(writeSamplesByChannel, sampleRate, bitDepth);
         _profAdd("write", _twrite);
+        this.progress(Math.min(outStart + chunkFrames, processStftFrames), processStftFrames);
       }
       if (outputBuffer.frames < totalFrames) {
         const padFrames = totalFrames - outputBuffer.frames;
@@ -37981,6 +38003,7 @@ var DtlnStream = class extends BufferedTransformStream {
     const writerState = { written: 0 };
     const pumpDone = pair !== void 0 ? pumpSourceToResampleIn({ buffer, resampleIn: pair.resampleIn, channels, chunkFrames: CHUNK_FRAMES5 }) : Promise.resolve();
     const drainerDone = pair !== void 0 ? drainResampleOutToBuffer({ resampleOut: pair.resampleOut, output, channels, sourceRate, bitDepth, originalFrames, writerState }) : Promise.resolve();
+    const total16k = Math.round(originalFrames * DTLN_SAMPLE_RATE / sourceRate);
     for (; ; ) {
       const got16k = await pullNextChunkAt16k({ buffer, pair, channels, frames: CHUNK_FRAMES5 });
       if (got16k === void 0) break;
@@ -38011,6 +38034,7 @@ var DtlnStream = class extends BufferedTransformStream {
           }
         }
       }
+      this.progress(Math.min(samplesFed, total16k), total16k);
     }
     await pumpDone;
     if (samplesFed > 0 && samplesFed < BLOCK_LEN) {
@@ -38222,6 +38246,7 @@ var HtdemucsStream = class extends BufferedTransformStream {
     const bitDepth = this.bitDepth;
     const needsResample = sourceRate !== HTDEMUCS_SAMPLE_RATE;
     const stats = await computeStreamingStats(buffered, channels);
+    this.log("streaming stats computed", { mean: stats.mean, std: stats.std });
     await buffered.reset();
     let pair;
     if (needsResample) {
@@ -38307,6 +38332,8 @@ var HtdemucsStream = class extends BufferedTransformStream {
     const { stems } = this.properties;
     const stemGains = [stems.drums, stems.bass, stems.other, stems.vocals];
     const inv = 1 / (stats.std || 1);
+    const modelRateFrames = Math.round(originalFrames * HTDEMUCS_SAMPLE_RATE / sourceRate);
+    let stableEmitted = 0;
     for (; ; ) {
       if (!inputExhausted) {
         while (segFilled < SEGMENT_SAMPLES) {
@@ -38361,6 +38388,8 @@ var HtdemucsStream = class extends BufferedTransformStream {
         originalFrames,
         writerState
       });
+      stableEmitted += nStable;
+      this.progress(Math.min(stableEmitted, modelRateFrames), modelRateFrames);
       if (!isFinalIter) {
         segLeft.copyWithin(0, nStable, SEGMENT_SAMPLES);
         segRight.copyWithin(0, nStable, SEGMENT_SAMPLES);
@@ -38784,6 +38813,8 @@ var KimVocal2Stream = class extends BufferedTransformStream {
     const outAccumLeft = new Float32Array(SEGMENT_SAMPLES2);
     const outAccumRight = new Float32Array(SEGMENT_SAMPLES2);
     const sumWeight = new Float32Array(SEGMENT_SAMPLES2);
+    const modelRateFrames = Math.round(originalFrames * SAMPLE_RATE / sourceRate);
+    let stableEmitted = 0;
     for (; ; ) {
       if (!inputExhausted) {
         while (segFilled < SEGMENT_SAMPLES2) {
@@ -38829,6 +38860,8 @@ var KimVocal2Stream = class extends BufferedTransformStream {
         originalFrames,
         writerState
       });
+      stableEmitted += nStable;
+      this.progress(Math.min(stableEmitted, modelRateFrames), modelRateFrames);
       if (!isFinalIter) {
         segLeft.copyWithin(0, nStable, SEGMENT_SAMPLES2);
         segRight.copyWithin(0, nStable, SEGMENT_SAMPLES2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buffered-audio/nodes",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "type": "module",
   "exports": {
     ".": {
@@ -45,8 +45,8 @@
     "vitest": "^3.0.0"
   },
   "dependencies": {
-    "@buffered-audio/core": "0.7.0",
-    "@buffered-audio/utils": "0.6.0",
+    "@buffered-audio/core": "0.7.2",
+    "@buffered-audio/utils": "0.6.2",
     "bufferfy": "^4.0.3",
     "commander": "^14.0.3",
     "tsx": "^4.21.0",