@libraz/libsonare 1.8.0 → 1.8.2

package/src/index.ts

@@ -61,6 +61,7 @@ export type {
   DynamicsProcessorResult,
   GateOptions,
   MasteringAbMatchLoudnessRequest,
+  MasteringAbMatchLoudnessStereoRequest,
   MasteringAmpPresetCatalogEntry,
   MasteringAssistantParamsRequest,
   MasteringAssistantStereoParamsRequest,
@@ -74,6 +75,7 @@ export type {
   MasteringInsertTiming,
   MasteringPairAnalyzeRequest,
   MasteringPairProcessRequest,
+  MasteringPairProcessStereoRequest,
   MasteringProcessorCatalogEntry,
   MasteringProcessorCategory,
   MasteringProcessRequest,
@@ -132,6 +134,7 @@ export {
   masterAudioWithProgress,
   mastering,
   masteringAbMatchLoudness,
+  masteringAbMatchLoudnessStereo,
   masteringAmpPresetCatalog,
   masteringAssistantSuggest,
   masteringAssistantSuggestChain,
@@ -154,6 +157,7 @@ export {
   masteringPairAnalyze,
   masteringPairProcess,
   masteringPairProcessorNames,
+  masteringPairProcessStereo,
   masteringPlatformNames,
   masteringPresetNames,
   masteringPresetParams,
@@ -542,6 +546,9 @@ export type {
   MidiCcLearnOptions,
   MpeDimension,
   NoteTracking,
+  PartRig,
+  PartRigInsert,
+  PartRigMode,
   ProjectAssistSidecar,
   ProjectAssistSidecarInput,
   ProjectAutomationCurve,
@@ -556,6 +563,7 @@ export type {
   ProjectClipFade,
   ProjectClipTake,
   ProjectCompileResult,
+  ProjectCompileTimelineResult,
   ProjectFadeCurve,
   ProjectKeySegment,
   ProjectLoopMode,
@@ -613,10 +621,13 @@ export {
   MarkerKind,
   MPE_DIMENSIONS,
   NOTE_TRACKINGS,
+  PART_RIG_ALL_PARTS,
+  PART_RIG_MODES,
   PROJECT_AUTOMATION_TARGET_OPAQUE,
   PROJECT_AUTOMATION_TARGET_TRACK_FADER_DB,
   PROJECT_AUTOMATION_TARGET_TRACK_PAN,
   Project,
+  ProjectTimeline,
   projectAbiVersion,
   SAMPLE_KEY_TRACKS,
   SAMPLE_LOOP_MODES,
@@ -687,6 +698,7 @@ export type {
   KeyDetectionOptions,
   KeyProfileName,
   LoudnessMatchResult,
+  LoudnessMatchStereoResult,
   LufsResult,
   LufsSeriesResult,
   MasteringAssistantParams,
@@ -807,6 +819,7 @@ export type {
   SpectralRegionOp,
   StageGainReduction,
   StereoAnalysis,
+  StereoPairProcessor,
   StftPowerResult,
   StftResult,
   StreamingEqualizerConfig,
@@ -829,6 +842,7 @@ export {
   PitchClass,
   SectionType,
 } from './public_types';
+export type * from './public_types_vocal_edit';
 export type {
   AnalyzeBpmRequest,
   AnalyzeDynamicsRequest,
@@ -953,6 +967,29 @@ export {
 export type { TranscribeRequest } from './transcribe';
 export { transcribe } from './transcribe';
 export type { ValidateOptions } from './validation';
+export {
+  createVocalEditSession,
+  restoreVocalEditSession,
+  VocalEditDraft,
+  VocalEditSession,
+  VocalRenderJob,
+  VocalRenderSnapshot,
+  vocalEditApiVersion,
+  vocalEditAvailable,
+} from './vocal_edit';
+export type {
+  VocalEditWorker,
+  VocalEditWorkerCallOptions,
+  VocalEditWorkerClientOptions,
+  VocalEditWorkerTransferOptions,
+} from './vocal_edit_worker_client';
+export {
+  VocalEditWorkerClient,
+  VocalEditWorkerSession,
+  VocalEditWorkerStaleResultError,
+  VocalEditWorkerTask,
+} from './vocal_edit_worker_client';
+export type * from './vocal_edit_worker_protocol';
 export type {
   BindWebMidiOptions,
   WebMidiBinding,
@@ -1148,3 +1185,5 @@ export function realtimeVoiceChangerPresetConfig(
 // ============================================================================
 
 export { PitchClass as Pitch } from './public_types';
+
+export type * from './public_types_vocal_project';

package/src/instrument_types.ts

@@ -228,6 +228,16 @@ export const CONTROLLER_AXES = [
  */
 export const ARTICULATIONS = ['poly', 'mono-retrigger', 'mono-legato'] as const;
 
+/**
+ * How a part's signal path is built. `'bank'` keeps whatever the instrument's
+ * own bank/program selection resolves to, `'none'` bypasses the rig stage, and
+ * `'chain'` replaces it with an explicit insert chain.
+ */
+export const PART_RIG_MODES = ['bank', 'none', 'chain'] as const;
+
+/** The `part` value that addresses a destination's default instead of one part (0-15). */
+export const PART_RIG_ALL_PARTS = 0xff;
+
 /** The three dimensions MPE carries per note ({@link RealtimeEngine.setControllerNoteTracking}). */
 export const MPE_DIMENSIONS = ['bend', 'pressure', 'timbre'] as const;
 
@@ -380,6 +390,23 @@ export type ControllerAxis = (typeof CONTROLLER_AXES)[number];
 /** Per-channel note-overlap rule ({@link RealtimeEngine.setArticulation}). */
 export type Articulation = (typeof ARTICULATIONS)[number];
 
+/** How a part's rig is built ({@link PART_RIG_MODES}). */
+export type PartRigMode = (typeof PART_RIG_MODES)[number];
+
+/** One stage of a `'chain'` part rig: a processor name and its parameters. */
+export interface PartRigInsert {
+  processor: string;
+  /** Processor parameters, as an object or an already-serialized JSON object string. */
+  params?: Record<string, unknown> | string;
+}
+
+/** A part rig as stored on a project ({@link Project.getPartRig}). */
+export interface PartRig {
+  mode: PartRigMode;
+  /** Present for `'chain'` only; `params` is the parsed parameter object. */
+  inserts?: { processor: string; params: Record<string, unknown> }[];
+}
+
 /** One per-note MPE dimension ({@link MPE_DIMENSIONS}). */
 export type MpeDimension = (typeof MPE_DIMENSIONS)[number];
 
@@ -582,9 +609,8 @@ export interface SynthPatch {
    * whose per-note kit patch replaces this whole section and never reads it.
    *
    * Also automatable under this same name through
-   * {@link RealtimeEngine.resolveInstrumentAutomationId}; it is one of the names
-   * that reaches a voice that is already sounding, rather than waiting for the
-   * next note.
+   * {@link RealtimeEngine.resolveInstrumentAutomationId}; it reaches
+   * already-sounding voices from the next processed block.
    */
   pitchOffsetCents?: number;
   ampAttackMs?: number;

package/src/mastering_core.ts

@@ -2,6 +2,7 @@ import { ErrorCode, SonareError } from './errors';
 import { getSonareModule } from './module_state';
 import type {
   LoudnessMatchResult,
+  LoudnessMatchStereoResult,
   MasteringAssistantParams,
   MasteringInsertParamChoice,
   MasteringInsertSlot,
@@ -13,6 +14,7 @@ import type {
   PairProcessor,
   SoloProcessor,
   StereoAnalysis,
+  StereoPairProcessor,
   StreamingPlatform,
 } from './public_types';
 
@@ -52,6 +54,17 @@ export interface MasteringPairProcessRequest {
   params?: MasteringProcessorParams;
 }
 
+/** Canonical request form for a stereo two-input match processor. */
+export interface MasteringPairProcessStereoRequest {
+  processorName: StereoPairProcessor;
+  sourceLeft: Float32Array;
+  sourceRight: Float32Array;
+  referenceLeft: Float32Array;
+  referenceRight: Float32Array;
+  sampleRate?: number;
+  params?: MasteringProcessorParams;
+}
+
 /** Canonical request form for {@link masteringAbMatchLoudness}. */
 export interface MasteringAbMatchLoudnessRequest {
   /** The take to gain-match. */
@@ -61,6 +74,15 @@ export interface MasteringAbMatchLoudnessRequest {
   sampleRate?: number;
 }
 
+/** Canonical request form for stereo AB loudness matching. */
+export interface MasteringAbMatchLoudnessStereoRequest {
+  sourceLeft: Float32Array;
+  sourceRight: Float32Array;
+  referenceLeft: Float32Array;
+  referenceRight: Float32Array;
+  sampleRate?: number;
+}
+
 /** Canonical request form for a two-input match analysis. */
 export interface MasteringPairAnalyzeRequest {
   analysisName: PairAnalysis;
@@ -548,6 +570,60 @@ export function masteringPairProcess(
   );
 }
 
+/**
+ * Apply the stereo `match.abCrossfade` processor. Source and reference stereo
+ * pairs may have independent lengths, but each pair must have equal channels.
+ */
+export function masteringPairProcessStereo(
+  request: MasteringPairProcessStereoRequest,
+): MasteringStereoResult;
+export function masteringPairProcessStereo(
+  processorName: StereoPairProcessor,
+  sourceLeft: Float32Array,
+  sourceRight: Float32Array,
+  referenceLeft: Float32Array,
+  referenceRight: Float32Array,
+  sampleRate?: number,
+  params?: MasteringProcessorParams,
+): MasteringStereoResult;
+export function masteringPairProcessStereo(
+  processorName: StereoPairProcessor | MasteringPairProcessStereoRequest,
+  sourceLeft?: Float32Array,
+  sourceRight?: Float32Array,
+  referenceLeft?: Float32Array,
+  referenceRight?: Float32Array,
+  sampleRate = 22050,
+  params: MasteringProcessorParams = {},
+): MasteringStereoResult {
+  const request =
+    typeof processorName === 'string'
+      ? {
+          processorName,
+          sourceLeft: sourceLeft as Float32Array,
+          sourceRight: sourceRight as Float32Array,
+          referenceLeft: referenceLeft as Float32Array,
+          referenceRight: referenceRight as Float32Array,
+          sampleRate,
+          params,
+        }
+      : processorName;
+  if (request.sourceLeft.length !== request.sourceRight.length) {
+    throw new Error('Source left and right channel lengths must match.');
+  }
+  if (request.referenceLeft.length !== request.referenceRight.length) {
+    throw new Error('Reference left and right channel lengths must match.');
+  }
+  return requireModule().masteringPairProcessStereo(
+    request.processorName,
+    request.sourceLeft,
+    request.sourceRight,
+    request.referenceLeft,
+    request.referenceRight,
+    request.sampleRate ?? 22050,
+    request.params ?? {},
+  );
+}
+
 /**
  * Analyze a `source` against a `reference` with a two-input analysis. The two
  * buffers may have independent lengths.
@@ -616,6 +692,25 @@ export function masteringAbMatchLoudness(
   );
 }
 
+/** Gain-match a stereo source to a stereo reference with one shared gain. */
+export function masteringAbMatchLoudnessStereo(
+  request: MasteringAbMatchLoudnessStereoRequest,
+): LoudnessMatchStereoResult {
+  if (request.sourceLeft.length !== request.sourceRight.length) {
+    throw new Error('Source left and right channel lengths must match.');
+  }
+  if (request.referenceLeft.length !== request.referenceRight.length) {
+    throw new Error('Reference left and right channel lengths must match.');
+  }
+  return requireModule().masteringAbMatchLoudnessStereo(
+    request.sourceLeft,
+    request.sourceRight,
+    request.referenceLeft,
+    request.referenceRight,
+    request.sampleRate ?? 22050,
+  );
+}
+
 export function masteringStereoAnalyze(request: MasteringStereoAnalyzeRequest): string;
 export function masteringStereoAnalyze(
   analysisName: StereoAnalysis,
@@ -829,11 +924,12 @@ export function masteringAssistantSuggestChainStereo(
 /**
  * Mastering assistant profile of a stereo pair, as shared JSON.
  *
- * Only the `loudness` block is measured from the two channels: integrated LUFS
+ * The `loudness` block is measured from the two channels: integrated LUFS
  * and LRA come from the channel-summed program and the true peak is the larger
  * of the two. The spectral, dynamics and tempo fields describe shape and timing
  * rather than absolute level and are measured on the downmix, which keeps them
- * comparable with {@link masteringAudioProfile}.
+ * comparable with {@link masteringAudioProfile}. Defect detectors run on each
+ * channel and their results are aggregated.
  */
 export function masteringAudioProfileStereo(request: MasteringStereoParamsRequest): string {
   return requireModule().masteringAudioProfileStereo(

package/src/mixer.ts

@@ -188,50 +188,70 @@ export class Mixer {
    * after {@link delete}.
    */
   createRealtimeBuffer(): MixerRealtimeBuffer {
-    const stripCount = this.stripCount();
-    let leftInputs: Float32Array[] = [];
-    let rightInputs: Float32Array[] = [];
+    const leftInputs: Float32Array[] = [];
+    const rightInputs: Float32Array[] = [];
     let outLeft = this.mixer.outputLeftView();
     let outRight = this.mixer.outputRightView();
+    let acquiredStripCount = -1;
+
+    // Every view shares one heap buffer, so a growth detaches the output views too.
+    const viewsDetached = (): boolean => outLeft.byteLength === 0 || outRight.byteLength === 0;
+
     const acquire = (): void => {
-      leftInputs = [];
-      rightInputs = [];
-      for (let index = 0; index < stripCount; index++) {
+      const stripCount = this.stripCount();
+      const detached = viewsDetached();
+      if (detached) {
+        // A heap growth detached every view: reacquire all planes.
+        leftInputs.length = 0;
+        rightInputs.length = 0;
+      } else {
+        // Topology growth keeps existing planes in place: append views for new strips only.
+        leftInputs.length = Math.min(leftInputs.length, stripCount);
+        rightInputs.length = Math.min(rightInputs.length, stripCount);
+      }
+      for (let index = leftInputs.length; index < stripCount; index++) {
         leftInputs.push(this.mixer.inputLeftView(index));
+      }
+      for (let index = rightInputs.length; index < stripCount; index++) {
         rightInputs.push(this.mixer.inputRightView(index));
       }
-      outLeft = this.mixer.outputLeftView();
-      outRight = this.mixer.outputRightView();
+      if (detached) {
+        outLeft = this.mixer.outputLeftView();
+        outRight = this.mixer.outputRightView();
+      }
+      acquiredStripCount = stripCount;
     };
     acquire();
+
     // The cached heap views can detach if WASM linear memory grows (the embind
-    // module is built ALLOW_MEMORY_GROWTH). Re-acquire them if detached
-    // (byteLength === 0) before use, mirroring the worklet RT path.
-    const reacquireIfDetached = (): void => {
-      if (outLeft.byteLength === 0 || (leftInputs[0]?.byteLength ?? 1) === 0) {
+    // module is built ALLOW_MEMORY_GROWTH). Also refresh the view list when a
+    // caller adds a strip and recompiles the graph after this buffer was made.
+    const acquireIfNeeded = (): void => {
+      if (acquiredStripCount !== this.stripCount() || viewsDetached()) {
         acquire();
       }
     };
     return {
       get leftInputs(): Float32Array[] {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return leftInputs;
       },
       get rightInputs(): Float32Array[] {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return rightInputs;
       },
       get outLeft(): Float32Array {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return outLeft;
       },
       get outRight(): Float32Array {
-        reacquireIfDetached();
+        acquireIfNeeded();
         return outRight;
       },
-      process: (numSamples = outLeft.length) => {
-        reacquireIfDetached();
-        this.mixer.processPreparedStereo(numSamples);
+      process: (numSamples?: number) => {
+        acquireIfNeeded();
+        // Resolve the default only after reacquiring: a detached view reports length 0.
+        this.mixer.processPreparedStereo(numSamples ?? outLeft.length);
       },
     };
   }
@@ -484,8 +504,8 @@ export class Mixer {
   }
 
   /**
-   * Set a per-strip channel delay in samples. This changes the strip's reported
-   * latency; recompile to re-run latency compensation.
+   * Set a per-strip channel delay in samples, moving the strip later relative to
+   * the others. It is not latency: latency compensation does not undo it.
    */
   setChannelDelaySamples(stripIndex: number, delaySamples: number): void {
     this.mixer.setChannelDelaySamples(stripIndex, delaySamples);

package/src/project.ts

@@ -8,6 +8,9 @@ export type {
   ControllerInput,
   MpeDimension,
   NoteTracking,
+  PartRig,
+  PartRigInsert,
+  PartRigMode,
   SampleDesc,
   SampleDescLoopMode,
   SampleKeyTrack,
@@ -35,6 +38,8 @@ export {
   CONTROLLER_INPUTS,
   MPE_DIMENSIONS,
   NOTE_TRACKINGS,
+  PART_RIG_ALL_PARTS,
+  PART_RIG_MODES,
   SAMPLE_KEY_TRACKS,
   SAMPLE_LOOP_MODES,
   SYNTH_BODY_TYPES,
@@ -46,7 +51,7 @@ export {
   SYNTH_OSC_WAVEFORMS,
   SYNTH_RETRIGGERS,
 } from './instrument_types';
-export { Project } from './project_class';
+export { Project, ProjectTimeline } from './project_class';
 export {
   controllerProfileNames,
   projectAbiVersion,
@@ -79,6 +84,7 @@ export type {
   ProjectClipFade,
   ProjectClipTake,
   ProjectCompileResult,
+  ProjectCompileTimelineResult,
   ProjectDeserializeResult,
   ProjectDiagnostic,
   ProjectFadeCurve,
@@ -121,4 +127,5 @@ export {
   PROJECT_AUTOMATION_TARGET_TRACK_FADER_DB,
   PROJECT_AUTOMATION_TARGET_TRACK_PAN,
 } from './project_types';
+export type * from './public_types_vocal_project';
 export { SampleBank } from './sample_bank';

package/src/project_class.ts

@@ -1,5 +1,8 @@
 import type {
   BuiltinSynthBinding,
+  PartRig,
+  PartRigInsert,
+  PartRigMode,
   Sf2InstrumentConfig,
   Sf2ProgramStatus,
   SynthPatch,
@@ -7,6 +10,8 @@ import type {
 import {
   assertProjectMidiEvents,
   normalizeSynthInstrument,
+  partRigFromNative,
+  partRigInsertsJson,
   projectAutomationPointValue,
   projectAutomationTargetKindValue,
   projectLoopModeValue,
@@ -14,7 +19,10 @@ import {
   projectModule,
   projectTrackKindValue,
   projectWarpModeValue,
+  registerProjectTimeline,
+  unregisterProjectTimeline,
   type WasmProject,
+  type WasmProjectTimeline,
 } from './project_internal';
 import type {
   ExternalSeparatedStemImportRequest,
@@ -33,6 +41,7 @@ import type {
   ProjectClipFade,
   ProjectClipTake,
   ProjectCompileResult,
+  ProjectCompileTimelineResult,
   ProjectDeserializeResult,
   ProjectKeySegment,
   ProjectLoopMode,
@@ -60,6 +69,13 @@ import type {
   ProjectWarpMapDesc,
   ProjectWarpMode,
 } from './project_types';
+import type {
+  ProjectVocalEditApplyRequest,
+  ProjectVocalEditApplyResult,
+  ProjectVocalEditDependency,
+  ProjectVocalOriginalSource,
+  ProjectVocalRehydrateItem,
+} from './public_types_vocal_project';
 import {
   assertBoundedInteger,
   assertNibble,
@@ -67,6 +83,11 @@ import {
   assertSamples,
   assertU7,
 } from './validation';
+import {
+  projectApplyVocalEdit,
+  projectGetVocalEditDependencies,
+  projectRehydrateVocalEdits,
+} from './vocal_project';
 
 /**
  * Folds the positional and request call forms of `bakeMidiFx` into one shape,
@@ -171,6 +192,47 @@ function midi2Byte(fnName: string, value: number, argName: string): number {
   return value;
 }
 
+/**
+ * An immutable compiled snapshot of a {@link Project}, produced by
+ * {@link Project.compileTimeline} and installed into a stopped realtime engine
+ * with `RealtimeEngine.applyProjectTimeline`.
+ *
+ * An engine keeps its own reference after an apply, so {@link dispose} may be
+ * called right afterwards. The embind handle is not garbage-collected; release
+ * it when no further apply needs it.
+ */
+export class ProjectTimeline {
+  private native: WasmProjectTimeline | null;
+
+  /** @internal */
+  constructor(native: WasmProjectTimeline) {
+    this.native = native;
+    registerProjectTimeline(this, native);
+  }
+
+  /**
+   * Identity an engine names this timeline by, so no raw pointer crosses into JS.
+   *
+   * @internal
+   */
+  get nativeId(): number {
+    if (this.native === null) {
+      throw new TypeError('ProjectTimeline is disposed');
+    }
+    return this.native.id;
+  }
+
+  /** Release the underlying WASM object. Idempotent. */
+  dispose(): void {
+    if (this.native === null) {
+      return;
+    }
+    unregisterProjectTimeline(this);
+    this.native.delete();
+    this.native = null;
+  }
+}
+
 /**
  * Headless DAW project (control-thread-only arrangement model).
  *
@@ -199,7 +261,33 @@ function midi2Byte(fnName: string, value: number, argName: string): number {
  */
 export class Project {
   private native: WasmProject;
+
+  applyVocalEdit(request: ProjectVocalEditApplyRequest): ProjectVocalEditApplyResult {
+    return projectApplyVocalEdit(this.native, request);
+  }
+
+  getVocalEditDependencies(): ProjectVocalEditDependency[] {
+    return projectGetVocalEditDependencies(this.native);
+  }
+
+  rehydrateVocalEdits(
+    originals: readonly ProjectVocalOriginalSource[],
+    cancel?: () => boolean,
+  ): ProjectVocalRehydrateItem[] {
+    this.activeVocalRehydrateCalls += 1;
+    try {
+      return projectRehydrateVocalEdits(this.native, originals, cancel);
+    } finally {
+      this.activeVocalRehydrateCalls -= 1;
+      if (this.activeVocalRehydrateCalls === 0 && this.deleteRequested) {
+        this.native.delete();
+      }
+    }
+  }
+
   private released = false;
+  private deleteRequested = false;
+  private activeVocalRehydrateCalls = 0;
 
   constructor() {
     this.native = new (projectModule().Project)();
@@ -798,6 +886,34 @@ export class Project {
     this.native.setTrackGain(trackId, gain);
   }
 
+  /**
+   * Set the rig of one part (0-15), or of the destination's default when `part`
+   * is {@link PART_RIG_ALL_PARTS}, on MIDI destination `destinationId`, via an
+   * undoable edit. `'chain'` takes 1-8 `inserts` and is the only mode that does;
+   * a destination no track references is stored and read back all the same.
+   * Refused: a malformed insert document (invalid format), an out-of-range part,
+   * an unknown mode or processor, or inserts on a non-chain mode (invalid
+   * parameter), and an insert chain in a build without mastering.
+   */
+  setPartRig(
+    destinationId: number,
+    part: number,
+    mode: PartRigMode | number,
+    inserts?: PartRigInsert[],
+  ): void {
+    this.native.setPartRig(destinationId, part, mode, partRigInsertsJson(inserts));
+  }
+
+  /** The stored rig for `(destinationId, part)`, or null when none is stored. */
+  getPartRig(destinationId: number, part: number): PartRig | null {
+    return partRigFromNative(this.native.getPartRig(destinationId, part));
+  }
+
+  /** Remove the stored rig for `(destinationId, part)` via an undoable edit (no-op when absent). */
+  clearPartRig(destinationId: number, part: number): void {
+    this.native.clearPartRig(destinationId, part);
+  }
+
   /** Set a track's mute flag via an undoable edit (a muted track is silent). */
   setTrackMute(trackId: number, mute: boolean): void {
     this.native.setTrackMute(trackId, mute);
@@ -1059,6 +1175,17 @@ export class Project {
     return this.native.compile();
   }
 
+  /**
+   * Compile the project and keep the resulting timeline. The result is
+   * {@link compile}'s plus `timeline`: a {@link ProjectTimeline} to install with
+   * `RealtimeEngine.applyProjectTimeline`, or `null` when an error diagnostic
+   * means nothing compiled.
+   */
+  compileTimeline(): ProjectCompileTimelineResult {
+    const { timeline, ...result } = this.native.compileTimeline();
+    return { ...result, timeline: timeline === null ? null : new ProjectTimeline(timeline) };
+  }
+
   /**
    * Compile + render the project offline to interleaved float audio. MIDI
    * tracks render silently here (no instrument is bound) — use
@@ -1540,12 +1667,20 @@ export class Project {
     return this.native.lastBounceCompileResult();
   }
 
-  /** Release the underlying WASM object. Idempotent, as the Node facade is. */
+  /**
+   * Release the underlying WASM object. Idempotent, as the Node facade is.
+   * Called from a rehydrate cancel callback, the release happens when the
+   * outermost {@link rehydrateVocalEdits} call returns.
+   */
   delete(): void {
     if (this.released) {
       return;
     }
     this.released = true;
+    if (this.activeVocalRehydrateCalls !== 0) {
+      this.deleteRequested = true;
+      return;
+    }
     this.native.delete();
   }