@buffered-audio/nodes 0.16.0 → 0.18.0

package/README.md

@@ -63,13 +63,27 @@ export default chain(read("input.wav"), normalize(), trim({ threshold: -60 }), w
 Render a `.bag` (Buffered Audio Graph) file. BAG files are JSON-serialized graph definitions.
 
 ```bash
-npx @buffered-audio/nodes render --bag pipeline.bag
+npx @buffered-audio/nodes render pipeline.bag
 ```
 
-| Flag                        | Description                         |
-| --------------------------- | ----------------------------------- |
-| `--chunk-size <samples>`    | Chunk size in samples               |
-| `--high-water-mark <count>` | Stream backpressure high water mark |
+| Flag                        | Description                                                  |
+| --------------------------- | ----------------------------------------------------------- |
+| `--chunk-size <samples>`    | Chunk size in samples                                       |
+| `--high-water-mark <count>` | Stream backpressure high water mark                         |
+| `--param <name=value>`      | Bind a `{{name}}` template placeholder (repeatable)         |
+
+#### Template parameters
+
+String values in a bag's node `parameters` may contain `{{name}}` placeholders. Each `--param name=value` binds one for that render; the same bag renders different inputs and outputs without editing the file. Every placeholder must be bound, and every `--param` must match a placeholder, or the render fails before any audio work.
+
+```json
+{ "id": "a", "packageName": "@buffered-audio/nodes", "packageVersion": "0.16.0", "nodeName": "Read",  "parameters": { "path": "{{episode}}/raw.wav" } }
+{ "id": "z", "packageName": "@buffered-audio/nodes", "packageVersion": "0.16.0", "nodeName": "Write", "parameters": { "path": "{{episode}}/master.wav" } }
+```
+
+```bash
+npx @buffered-audio/nodes render master.bag --param episode=./e260
+```
 
 ## Nodes
 
@@ -164,7 +178,7 @@ Remove background noise from speech using DTLN neural network
 
 ### Duplicate Channels
 
-Duplicate a mono signal into multiple identical output channels
+Duplicate a mono signal into multiple identical output channels; requires exactly 1 input channel, throws otherwise
 
 [Source](./src/transforms/duplicate-channels/index.ts)
 
@@ -285,7 +299,7 @@ Add silence to start or end of audio
 
 ### Pan
 
-Position mono signal in stereo field or adjust stereo balance
+Position mono signal in stereo field or adjust stereo balance; throws for inputs with more than 2 channels
 
 [Source](./src/transforms/pan/index.ts)
 
@@ -304,18 +318,6 @@ Invert or rotate signal phase
 | `invert` | boolean | `true` | Invert |
 | `angle` | number (-180 to 180, step 1), optional | — | Angle |
 
-### Read
-
-Read audio from a file
-
-[Source](./src/sources/read/index.ts)
-
-| Parameter | Type | Default | Description |
-| --- | --- | --- | --- |
-| `path` | string | `""` |  |
-| `ffmpegPath` | string | `""` | FFmpeg — audio/video processing tool Download: [ffmpeg](https://ffmpeg.org/download.html) |
-| `ffprobePath` | string | `""` | FFprobe — media file analyzer (included with FFmpeg) Download: [ffprobe](https://ffmpeg.org/download.html) |
-
 ### Read FFmpeg
 
 Read audio from a file using FFmpeg
@@ -404,7 +406,6 @@ Host a chain of VST3 effect plugins via Pedalboard (whole-file offline mode)
 | `stages[].pluginPath` | string | — | VST3 plugin file or bundle |
 | `stages[].pluginName` | string, optional | — | Sub-plugin name when pluginPath is a multi-plugin shell (e.g. WaveShell) |
 | `stages[].presetPath` | string, optional | — | Optional .vstpreset state file applied after the plugin loads |
-| `stages[].parameters` | record, optional | — | Optional parameter overrides applied after presetPath. Keys map to Pedalboard parameter names exposed by the plugin. |
 | `bypass` | boolean | `false` | Pass audio through unchanged (no subprocess spawn) |
 
 ### Waveform
@@ -508,9 +509,9 @@ class NormalizeStream extends BufferedTransformStream<NormalizeProperties> {
 }
 
 class NormalizeNode extends TransformNode<NormalizeProperties> {
-	static override readonly moduleName = "Normalize";
+	static override readonly nodeName = "Normalize";
 	static override readonly packageName = "buffered-audio-nodes";
-	static override readonly moduleDescription = "Adjust peak or loudness level to a target ceiling";
+	static override readonly nodeDescription = "Adjust peak or loudness level to a target ceiling";
 	static override readonly schema = schema;
 
 	override readonly type = ["buffered-audio-node", "transform", "normalize"] as const;

package/dist/cli.js

@@ -2,8 +2,95 @@
 import { Command } from 'commander';
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { SourceNode, validateGraphDefinition, renderGraph } from '@buffered-audio/core';
+import { SourceNode, validateGraphDefinition, createRenderJobs, BufferedSourceStream } from '@buffered-audio/core';
 
+var labelOf = (node) => node.id ? `${node.nodeName}#${node.id}` : node.nodeName;
+function sourceLabel(job) {
+  for (const [node, streams] of job.streams) {
+    if (streams.some((stream) => stream instanceof BufferedSourceStream)) {
+      return labelOf({ nodeName: node.constructor.nodeName, id: node.id });
+    }
+  }
+  return void 0;
+}
+var collect = (value, previous) => [...previous, value];
+function parseParams(entries) {
+  const parameters = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const separatorIndex = entry.indexOf("=");
+    if (separatorIndex === -1) {
+      process.stderr.write(`Error: --param must be in name=value form, got "${entry}"
+`);
+      process.exit(1);
+    }
+    const name = entry.slice(0, separatorIndex);
+    const value = entry.slice(separatorIndex + 1);
+    if (name === "") {
+      process.stderr.write(`Error: --param name must not be empty, got "${entry}"
+`);
+      process.exit(1);
+    }
+    if (parameters.has(name)) {
+      process.stderr.write(`Error: --param ${name} given more than once
+`);
+      process.exit(1);
+    }
+    parameters.set(name, value);
+  }
+  return Object.fromEntries(parameters);
+}
+function createEventSink() {
+  const totals = /* @__PURE__ */ new Map();
+  const subscribe = (events) => {
+    events.on("started", (node) => {
+      process.stdout.write(`[${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}%
+`);
+      } else {
+        process.stdout.write(`[${label}] ${payload.phase} frames=${payload.framesDone}
+`);
+      }
+    });
+    events.on("log", (node, payload) => {
+      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}
+`);
+    });
+    events.on("finished", (node, payload) => {
+      totals.set(node, { framesDone: payload.framesDone, processingMs: payload.processingMs });
+      process.stdout.write(`[${labelOf(node)}] finished
+`);
+    });
+  };
+  const printSummary = (jobs) => {
+    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
+`);
+      } else {
+        process.stdout.write(`[${label}] processed ${framesDone} frames
+`);
+      }
+    }
+    for (const job of jobs) {
+      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
+`);
+    }
+  };
+  return { subscribe, printSummary };
+}
 var program = new Command();
 program.name("buffered-audio-nodes").description("Process audio through buffered audio node pipelines");
 program.command("process").description("Run an async audio processing pipeline").requiredOption("--pipeline <file>", "TypeScript file with default SourceAsyncModule export").option("--chunk-size <samples>", "Chunk size in samples").option("--high-water-mark <count>", "Stream backpressure high water mark").action(async (options) => {
@@ -34,19 +121,19 @@ program.command("process").description("Run an async audio processing pipeline")
 `);
       process.exit(1);
     }
-    const renderOptions = {
-      chunkSize,
-      highWaterMark
-    };
+    const sink = createEventSink();
+    const job = source.createRenderJob({ chunkSize, highWaterMark });
+    sink.subscribe(job.events);
     process.stdout.write(`Processing pipeline: ${pipelinePath}
 `);
-    await source.render(renderOptions);
+    await job.render();
+    sink.printSummary([job]);
     process.stdout.write("Done.\n");
   } finally {
     await unregister();
   }
 });
-program.command("render").description("Render a .bag graph definition file").argument("<file>", "Path to .bag file (JSON)").option("--chunk-size <samples>", "Chunk size in samples").option("--high-water-mark <count>", "Stream backpressure high water mark").action(async (file, options) => {
+program.command("render").description("Render a .bag graph definition file").argument("<file>", "Path to .bag file (JSON)").option("--chunk-size <samples>", "Chunk size in samples").option("--high-water-mark <count>", "Stream backpressure high water mark").option("--param <name=value>", "Bind a {{name}} template placeholder in the bag (repeatable)", collect, []).action(async (file, options) => {
   const bagPath = resolve(file);
   if (!existsSync(bagPath)) {
     process.stderr.write(`Error: file not found: ${bagPath}
@@ -66,18 +153,29 @@ program.command("render").description("Render a .bag graph definition file").arg
         for (const value of Object.values(mod)) {
           if (typeof value !== "function") continue;
           const ctor = value;
-          if (typeof ctor.moduleName !== "string") continue;
-          packageMap.set(ctor.moduleName, ctor);
+          if (typeof ctor.nodeName !== "string") continue;
+          packageMap.set(ctor.nodeName, ctor);
         }
         registry.set(nodeDef.packageName, packageMap);
       }
     }
     const chunkSize = options.chunkSize ? parseInt(options.chunkSize, 10) : void 0;
     const highWaterMark = options.highWaterMark ? parseInt(options.highWaterMark, 10) : void 0;
+    const parameters = parseParams(options.param);
+    const sink = createEventSink();
     process.stdout.write(`Rendering graph: ${definition.name}
 `);
-    await renderGraph(definition, registry, { chunkSize, highWaterMark });
-    process.stdout.write("Done.\n");
+    try {
+      const jobs = createRenderJobs(definition, registry, { chunkSize, highWaterMark, parameters });
+      for (const job of jobs) sink.subscribe(job.events);
+      await Promise.all(jobs.map((job) => job.render()));
+      sink.printSummary(jobs);
+      process.stdout.write("Done.\n");
+    } catch (error) {
+      process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+      process.exitCode = 1;
+    }
   } finally {
     await unregister();
   }