@libraz/libsonare 1.7.1 → 1.7.2

package/dist/index.js

@@ -4015,6 +4015,20 @@ function projectLoopModeValue(mode) {
 }
 
 // src/project_class.ts
+function normalizeMidiFxBakeRequest(clipIdOrRequest, configJson) {
+  if (typeof clipIdOrRequest === "number") {
+    return {
+      clipId: clipIdOrRequest,
+      configJson: configJson ?? "",
+      withSourceIndex: false
+    };
+  }
+  return {
+    clipId: clipIdOrRequest.clipId,
+    configJson: clipIdOrRequest.configJson,
+    withSourceIndex: clipIdOrRequest.withSourceIndex ?? false
+  };
+}
 function validateAssistSidecarUint32(value, field) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
     throw new RangeError(`Project.setAssistSidecar: ${field} must be a uint32`);
@@ -4370,12 +4384,23 @@ var Project = class _Project {
   setProgramOnChannel(clipId, group, channel, program, bank = -1) {
     this.native.setProgramOnChannel(clipId, group, channel, program, bank);
   }
+  bakeMidiFx(clipIdOrRequest, configJson) {
+    const request = normalizeMidiFxBakeRequest(clipIdOrRequest, configJson);
+    if (!request.withSourceIndex) {
+      this.native.bakeMidiFx(request.clipId, request.configJson);
+      return {};
+    }
+    return {
+      sourceIndex: this.native.bakeMidiFxWithSourceIndex(request.clipId, request.configJson)
+    };
+  }
   /**
-   * Destructively bake a MIDI-FX chain into all stored events. Large clips are
-   * drained without truncation; failure leaves the original clip unchanged.
+   * Count the events {@link bakeMidiFx} would produce for this clip and
+   * configuration, without mutating the project. The transform is
+   * deterministic, so the count matches what the bake goes on to produce.
    */
-  bakeMidiFx(clipId, configJson) {
-    this.native.bakeMidiFx(clipId, configJson);
+  previewMidiFxCount(request) {
+    return this.native.previewMidiFxCount(request.clipId, request.configJson);
   }
   /** Backward alias for {@link bakeMidiFx}. */
   setMidiFx(clipId, configJson) {
@@ -5333,6 +5358,15 @@ var RealtimeEngine = class {
    * Returns `-1` when the track, insert, or name is unknown. (The Python binding
    * raises a `SonareError` for an unknown id where Node/WASM return the `-1`
    * sentinel.)
+   *
+   * This trio is how a mastering processor gets time-varying automation: the
+   * `eq.*`, `dynamics.*`, `saturation.*`, `spectral.*`, `stereo.*`,
+   * `maximizer.*` and `multiband.*` processors are all available as strip
+   * inserts, so placing one on a strip and resolving its parameter here drives
+   * it at audio-block precision, live and offline alike. The whole-signal
+   * stages of the offline mastering chain (`repair.*`, `loudness`, and the
+   * match stages) have no insert form and no automation id: they buffer the
+   * entire signal by construction and do not run on the realtime path.
    */
   resolveTrackInsertAutomationId(trackId, insertIndex, paramName) {
     return this.native.resolveTrackInsertAutomationId(trackId, insertIndex, paramName);
@@ -5460,6 +5494,33 @@ var RealtimeEngine = class {
   processPrepared(numFrames) {
     this.native.processPrepared(numFrames);
   }
+  /**
+   * Allocates the cue-bus counterpart of {@link prepareChannels}. Needed only
+   * when PFL/AFL monitoring must reach a separate output: `processPrepared`
+   * folds the cue bus into the program output, while
+   * {@link processPreparedWithMonitor} keeps the two apart. Call once, off the
+   * audio thread, with at least as many channels as `prepareChannels` got.
+   */
+  prepareMonitorChannels(numChannels, maxFrames) {
+    this.native.prepareMonitorChannels(numChannels, maxFrames);
+  }
+  /**
+   * Returns a Float32Array view onto the persistent cue-bus scratch for one
+   * channel (valid for up to `numFrames`). Read it after
+   * {@link processPreparedWithMonitor}. Re-acquire after WASM memory growth.
+   */
+  getMonitorChannelBuffer(channel, numFrames) {
+    return this.native.getMonitorChannelBuffer(channel, numFrames);
+  }
+  /**
+   * Runs the engine in place over the prepared scratch, writing the cue bus to
+   * the monitor scratch instead of folding it into the program output.
+   * Allocation-free: safe on the AudioWorklet render thread after
+   * `prepareChannels` and `prepareMonitorChannels`.
+   */
+  processPreparedWithMonitor(numFrames) {
+    this.native.processPreparedWithMonitor(numFrames);
+  }
   processWithMonitor(channels) {
     return this.native.processWithMonitor(channels);
   }