@libraz/libsonare 1.7.2 → 1.8.0

package/src/module_state.ts

@@ -22,7 +22,7 @@ interface NativeExceptionInfo {
  * Returns null when the thrown value is neither (a genuine JS error), so the
  * caller rethrows it unchanged.
  */
-function nativeExceptionPtr(error: unknown): number | null {
+export function nativeExceptionPtr(error: unknown): number | null {
   if (typeof error === 'number') {
     return error;
   }
@@ -38,7 +38,16 @@ function nativeExceptionPtr(error: unknown): number | null {
 /**
  * Turn a thrown native exception pointer into a {@link SonareError}. The bound
  * `sonareExceptionInfo` decodes the pointer back into { code, codeName,
- * message }.
+ * message }, then `sonareReleaseException` drops the reference emscripten's
+ * `__cxa_throw` took before rethrowing the pointer into JS.
+ *
+ * The release is mandatory, not an optimization: no C++ frame catches the
+ * exception, so that reference is the only one and nothing else ever drops it.
+ * Every rejected input would otherwise leak its exception object for the
+ * lifetime of the module — and rejection-as-control-flow (re-validating markers
+ * or clips on each edit, a scrub handle seeking every pointer move) is a
+ * documented usage of this API. It runs in a `finally` so a decode failure
+ * still frees, and after decoding because freeing invalidates the message.
  */
 function makeSonareError(raw: SonareModule, thrown: number): SonareError {
   let code: number = ErrorCode.Unknown;
@@ -55,6 +64,13 @@ function makeSonareError(raw: SonareModule, thrown: number): SonareError {
     }
   } catch {
     // Fall back to the generic message if decoding fails.
+  } finally {
+    try {
+      raw.sonareReleaseException(thrown);
+    } catch {
+      // A module built before the release binding existed still yields an error
+      // object; it just keeps leaking, which is what this replaces.
+    }
   }
   return new SonareError(code, codeName, message);
 }
@@ -85,6 +101,12 @@ function wrapModuleErrors(raw: SonareModule): SonareModule {
     if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Promise) {
       return value;
     }
+    // Plain result data carries no native methods, and a Proxy cannot be
+    // structured-cloned, so wrapping it would block postMessage to a worker.
+    const proto = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || proto === Object.prototype || proto === null) {
+      return value;
+    }
     const objectValue = value as object;
     const cached = objectCache.get(objectValue);
     if (cached) {

package/src/playback_renderer.ts

@@ -0,0 +1,252 @@
+import { getSonareModule } from './module_state';
+import type {
+  PlaybackDiagnostics,
+  PlaybackRendererConfig,
+  PlaybackRendererOptions,
+  RenderPlaybackRequest,
+  RenderPlaybackResult,
+} from './public_types_playback';
+import type { WasmHrtfSet, WasmPlaybackLoudnessMeter, WasmPlaybackRenderer } from './sonare.js';
+
+function configJsonText(config: PlaybackRendererConfig | string): string {
+  return typeof config === 'string' ? config : JSON.stringify(config);
+}
+
+/**
+ * Reads {@link HrtfSet}'s private `native`: TypeScript's `private` is a
+ * compile-time rule, so one reviewed read here beats widening the class with a
+ * handle accessor no caller wants.
+ */
+function nativeHrtf(hrtf: HrtfSet | undefined): WasmHrtfSet | null {
+  if (hrtf === undefined) {
+    return null;
+  }
+  if (!(hrtf instanceof HrtfSet)) {
+    throw new TypeError('hrtf must be an HrtfSet');
+  }
+  return (hrtf as unknown as { native: WasmHrtfSet }).native;
+}
+
+/**
+ * An HRTF set (SHRF v1): the direct-sound impulse responses and inter-aural
+ * time delays a headphones-target {@link PlaybackRenderer} convolves each
+ * virtual speaker's signal with.
+ *
+ * This build embeds no HRTF data. The package ships the default set as the
+ * asset `@libraz/libsonare/hrtf/default.shrf`; fetch or read it and pass the
+ * bytes to {@link HrtfSet.fromBytes}. A renderer built from a set keeps its
+ * own copy, so deleting the set right after construction is safe.
+ *
+ * @example
+ * ```ts
+ * const bytes = new Uint8Array(await (await fetch(hrtfUrl)).arrayBuffer());
+ * const hrtf = HrtfSet.fromBytes(bytes);
+ * const renderer = new PlaybackRenderer({ config: {}, hrtf, sampleRate: 48000 });
+ * hrtf.delete();
+ * ```
+ */
+export class HrtfSet {
+  private native: WasmHrtfSet;
+  private released = false;
+
+  private constructor(native: WasmHrtfSet) {
+    this.native = native;
+  }
+
+  /** Builds an HRTF set from SHRF v1 bytes; malformed data throws. */
+  static fromBytes(bytes: Uint8Array): HrtfSet {
+    return new HrtfSet(getSonareModule().createHrtfSet(bytes));
+  }
+
+  /** Releases the native handle. Idempotent, as the Node facade is. */
+  delete(): void {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.native.delete();
+  }
+
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy(): void {
+    this.delete();
+  }
+}
+
+/**
+ * Renders decoded movie audio (mono / stereo / 5.1 / 7.1 PCM) to headphones
+ * (binaural, head tracking, room model) or to stereo / 5.1 / 7.1 speakers
+ * (upmix, loudness alignment, night-mode DRC, dialogue level, speaker
+ * calibration, bass management).
+ *
+ * `config` follows `schemas/playback-renderer-config.schema.json`; see
+ * {@link PlaybackRendererConfig}. A headphones target requires `hrtf`.
+ *
+ * `processPlanar` copies every plane through the embind boundary, so it suits
+ * the main thread; like `processInterleaved`, a non-finite sample is replaced
+ * with 0 and counted rather than refused. The AudioWorklet path is
+ * `SonarePlaybackWorkletProcessor` in the worklet bundle.
+ */
+export class PlaybackRenderer {
+  private native: WasmPlaybackRenderer;
+  private released = false;
+
+  constructor(options: PlaybackRendererOptions) {
+    this.native = getSonareModule().createPlaybackRenderer(
+      configJsonText(options.config),
+      nativeHrtf(options.hrtf),
+      options.sampleRate ?? 48000,
+      options.maxBlockSize ?? 1024,
+    );
+  }
+
+  /**
+   * Renders one planar block; every plane must carry the same frame count, at
+   * most `maxBlockSize` (0 is a no-op). With a fixed input layout the plane
+   * count must equal {@link inputChannels}; with `input.layout: "auto"` it
+   * must be 1, 2, 6 or 8, and a change switches the input layout without
+   * changing the latency. Non-finite input samples are replaced with 0 and
+   * counted ({@link nonFiniteDiscardCount}).
+   */
+  processPlanar(planes: Float32Array[]): Float32Array[] {
+    return this.native.processPlanar(planes);
+  }
+
+  /** Interleaved variant of {@link processPlanar}. Non-finite input samples are replaced with 0 and counted. */
+  processInterleaved(samples: Float32Array, inChannels: number): Float32Array {
+    return this.native.processInterleaved(samples, inChannels);
+  }
+
+  /** Applies a complete configuration document; a changed prepare key throws. */
+  setConfig(config: PlaybackRendererConfig | string): void {
+    this.native.setConfig(configJsonText(config));
+  }
+
+  /** The current complete configuration document. */
+  config(): PlaybackRendererConfig {
+    return JSON.parse(this.native.configJson()) as PlaybackRendererConfig;
+  }
+
+  /**
+   * Publishes the listener head orientation in degrees: right-handed,
+   * positive yaw turns the head right, positive pitch looks up, positive roll
+   * lowers the right ear. Ignored by a speakers target; a non-finite angle is
+   * ignored.
+   */
+  setHeadOrientation(yawDeg: number, pitchDeg = 0, rollDeg = 0): void {
+    this.native.setHeadOrientation(yawDeg, pitchDeg, rollDeg);
+  }
+
+  /**
+   * Clears DSP state (filters, FIFOs, dynamics, convolution history, pending
+   * input-layout drains). Configuration and head pose are kept. Call it after
+   * a seek, from the thread that processes.
+   */
+  reset(): void {
+    this.native.reset();
+  }
+
+  /**
+   * Renderer latency in samples (headphones: near ear). Depends only on the
+   * target, the sample rate and distance compensation, never on realtime keys
+   * or the input layout.
+   */
+  latencySamples(): number {
+    return this.native.latencySamples();
+  }
+
+  /**
+   * Channel count of the active input layout. With `input.layout: "auto"`
+   * this follows the channel count of the most recent non-empty process call
+   * (2 before the first call).
+   */
+  inputChannels(): number {
+    return this.native.inputChannels();
+  }
+
+  /** Channel count of the output target. */
+  outputChannels(): number {
+    return this.native.outputChannels();
+  }
+
+  /**
+   * Inactive stages, per-stage latency, clamps, the active input layout, and
+   * the layout-switch / truncated-drain counters, as a plain object.
+   */
+  diagnostics(): PlaybackDiagnostics {
+    return JSON.parse(this.native.diagnosticsJson()) as PlaybackDiagnostics;
+  }
+
+  /** Non-finite input samples replaced with 0 since construction. */
+  nonFiniteDiscardCount(): number {
+    return this.native.nonFiniteDiscardCount();
+  }
+
+  /** Releases the native handle. Idempotent, as the Node facade is. */
+  delete(): void {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.native.delete();
+  }
+
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy(): void {
+    this.delete();
+  }
+}
+
+/**
+ * Integrated-loudness meter for multichannel program material (BS.1770
+ * channel weights by channel count: 1, 2, 6 or 8), for measuring
+ * `loudness.program_lufs` ahead of a {@link PlaybackRenderer}.
+ */
+export class PlaybackLoudnessMeter {
+  private native: WasmPlaybackLoudnessMeter;
+  private released = false;
+
+  constructor(channels: number, sampleRate: number) {
+    this.native = getSonareModule().createPlaybackLoudnessMeter(channels, sampleRate);
+  }
+
+  /** Feeds interleaved frames of any length. */
+  pushInterleaved(samples: Float32Array): void {
+    this.native.pushInterleaved(samples);
+  }
+
+  /** Integrated loudness of everything pushed so far, in LUFS. */
+  integratedLufs(): number {
+    return this.native.integratedLufs();
+  }
+
+  /** Releases the native handle. Idempotent, as the Node facade is. */
+  delete(): void {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    this.native.delete();
+  }
+
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy(): void {
+    this.delete();
+  }
+}
+
+/**
+ * Offline one-shot playback render: builds a renderer internally, feeds the
+ * whole interleaved signal through it, and removes the renderer's own latency
+ * so the output aligns with the input frame for frame.
+ * An empty or non-finite `samples` is refused with an `InvalidParameter` error.
+ */
+export function renderPlayback(request: RenderPlaybackRequest): RenderPlaybackResult {
+  return getSonareModule().renderPlayback(
+    request.samples,
+    request.channels,
+    request.sampleRate,
+    configJsonText(request.config),
+    nativeHrtf(request.hrtf),
+  );
+}

package/src/polyphony.ts

@@ -0,0 +1,279 @@
+import { ErrorCode, SonareError } from './errors';
+import { getSonareModule } from './module_state';
+import type {
+  NoteEditInput,
+  NoteObject,
+  PolyphonicAnalysisOptions,
+  PolyphonicRenderOptions,
+} from './public_types';
+import type { WasmPolyphonicAnalysis } from './sonare.js';
+import type { ValidateOptions } from './validation';
+import { assertSampleRate, assertSamples } from './validation';
+
+/** Canonical request form for {@link analyzePolyphonic}. */
+export interface AnalyzePolyphonicRequest extends PolyphonicAnalysisOptions, ValidateOptions {
+  samples: Float32Array;
+  /**
+   * Sample rate in Hz. Required: every duration in the chain — the ridge
+   * minimum, the note minimum, the per-frame windows — is converted to samples
+   * with this rate, so a wrong value silently analyses differently.
+   */
+  sampleRate: number;
+}
+
+/**
+ * A polyphonic analysis, held as a handle so one note of a chord can be edited
+ * and the result re-rendered without analysing the audio again.
+ *
+ * Created by {@link analyzePolyphonic}. **Release it with {@link destroy} as soon
+ * as you are done with it**: the handle owns the source's complex spectrogram plus
+ * the claimed bins of every note, which is the input over again plus the claims.
+ * That is the price of re-rendering an edit for free, and it is why this is a
+ * handle and not a result object — the measurement never crosses into JS.
+ *
+ * What crosses is what a host acts on: the notes ({@link notes}), each note's
+ * pending edit ({@link setNoteEdit}), the per-frame voice count
+ * ({@link polyphony}), and per note a pitch, a level and a salience curve. The
+ * spectrogram, the masks and the per-bin weights do not, and no method reports a
+ * per-bin figure.
+ *
+ * Using the analysis after it has been released throws `InvalidState` rather than
+ * reaching a freed native object.
+ */
+export class PolyphonicAnalysis {
+  private native: WasmPolyphonicAnalysis | null;
+
+  /** Analyses the request's audio. {@link analyzePolyphonic} is the same call. */
+  constructor(request: AnalyzePolyphonicRequest) {
+    assertSamples('analyzePolyphonic', request.samples, request.validate !== false);
+    assertSampleRate('analyzePolyphonic', request.sampleRate);
+    const module = getSonareModule();
+    this.native = module.createPolyphonicAnalysis(
+      request.samples,
+      request.sampleRate,
+      request as unknown as Record<string, unknown>,
+    );
+  }
+
+  private handle(): WasmPolyphonicAnalysis {
+    if (this.native === null) {
+      throw new SonareError(
+        ErrorCode.InvalidState,
+        'InvalidState',
+        'PolyphonicAnalysis has been released',
+      );
+    }
+    return this.native;
+  }
+
+  /** Number of notes, which is also the number of claim sets. */
+  get noteCount(): number {
+    return this.handle().noteCount;
+  }
+
+  /** Number of STFT frames the analysis ran over. */
+  get frameCount(): number {
+    return this.handle().frameCount;
+  }
+
+  /**
+   * Every note, in the order their claim sets are held in — the same
+   * {@link NoteObject} shape `extractNotes` returns, so a host that edits through
+   * both doors sees one note.
+   *
+   * Each note carries its sample span, its frame span (in the analysis's own
+   * framing), its median pitch, its steadiness, its per-frame `amplitude` and its
+   * pending edit. The curves a note does not carry inline have their own accessors:
+   * {@link noteF0}, {@link noteSalience}, and {@link noteEnvelope} for the points
+   * last set through {@link setNoteEdit}. `amplitude` is {@link noteAmplitude}'s
+   * curve, read once per note.
+   */
+  notes(): NoteObject[] {
+    return this.handle().notes();
+  }
+
+  /**
+   * Replaces one note's pending edit.
+   *
+   * The only thing a host writes. Everything else on a note is a measurement, and
+   * the order is the pairing with the claim sets, so neither is settable.
+   *
+   * An omitted field is the identity, so `{}` restores the identity edit. The
+   * envelope is `edit.amplitudeEnvelope`, which the handle copies, and its points
+   * are per-frame linear gains over the note's span on top of `gainDb` — stretched
+   * over whatever length the note renders at, so one entry is a constant gain and
+   * the count need not match the note's frame count. Every value must be finite
+   * and non-negative, which {@link render} is where it is checked, so one refusal
+   * names one place.
+   *
+   * @param note - Index below {@link noteCount}
+   * @throws {SonareError} `InvalidParameter` when `note` is out of range
+   */
+  setNoteEdit(note: number, edit: NoteEditInput): void {
+    this.handle().setNoteEdit(note, edit);
+  }
+
+  /**
+   * Voices estimated per frame, before tracking dropped anything — one entry per
+   * frame from frame 0.
+   *
+   * What the estimation saw rather than what survived: a frame reported as three
+   * voices with two notes spanning it is the difference between the two stages,
+   * which is the figure a host deciding what to edit wants.
+   */
+  polyphony(): Int32Array {
+    return this.handle().polyphony();
+  }
+
+  /**
+   * One note's F0 in Hz, per frame over its own span.
+   *
+   * `frameEnd - frameStart` entries, so the value at index `i` belongs to frame
+   * `frameStart + i`. This is the curve the monophonic door makes a caller pass
+   * back in; here the handle already holds it, so a curve edit needs nothing from
+   * the caller.
+   *
+   * @throws {SonareError} `InvalidParameter` when `note` is out of range
+   */
+  noteF0(note: number): Float32Array {
+    return this.handle().noteF0(note);
+  }
+
+  /** One note's linear RMS, per frame over its own span. Indexed as {@link noteF0}. */
+  noteAmplitude(note: number): Float32Array {
+    return this.handle().noteAmplitude(note);
+  }
+
+  /**
+   * One note's salience, per frame over its own span. Indexed as {@link noteF0},
+   * and the one curve here that is not the note's own: it is the tracked ridge's,
+   * so a frame of the note the ridge does not reach reads 0.
+   *
+   * Salience is what the estimation scored the candidate at, so it says how well
+   * the material supported this note rather than how loud the note is —
+   * {@link noteAmplitude} is the loud.
+   */
+  noteSalience(note: number): Float32Array {
+    return this.handle().noteSalience(note);
+  }
+
+  /**
+   * The stretch fitted for each note, one entry per note in {@link notes}' order.
+   *
+   * Empty when `estimateInharmonicity` was not set, so an empty array means the
+   * fit was never asked for. A non-negative entry is a fitted stretch; **exactly
+   * `-1` is the refusal**, and a refused note's claims were placed at the
+   * `inharmonicity` the request declared instead.
+   *
+   * **`0` is a fitted result and means the harmonic series**, which is why the
+   * refusal is reported at all: the declared stretch also defaults to 0, so the
+   * effective value alone cannot separate a fit that reached the material from one
+   * that did not. The fit refuses a chord at the default framing, so the
+   * distinction is the usual case rather than an edge one.
+   *
+   * @example
+   * ```typescript
+   * const analysis = analyzePolyphonic({ samples, sampleRate, estimateInharmonicity: true });
+   * const fitted = analysis.noteInharmonicity();
+   * const reached = [...fitted].filter((stretch) => stretch >= 0).length;
+   * ```
+   */
+  noteInharmonicity(): Float32Array {
+    return this.handle().noteInharmonicity();
+  }
+
+  /**
+   * One note's amplitude envelope points, as last set — the same array
+   * `notes()[note].edit.amplitudeEnvelope` carries.
+   *
+   * Indexed from 0 rather than over the note's span: an envelope is a set of gain
+   * points stretched over whatever length the note renders at, not a per-frame
+   * signal. The only one of the four curves that is not a measurement, and empty on
+   * a note carrying no envelope.
+   */
+  noteEnvelope(note: number): Float32Array {
+    return this.handle().noteEnvelope(note);
+  }
+
+  /**
+   * Renders the analysis back to audio with whatever edits its notes carry, at the
+   * source's length.
+   *
+   * Each note's claimed share is inverted, edited, and added to the residual — the
+   * part of the input no note claimed. With every edit identity the result is the
+   * analysis's own round trip, not the source bit for bit, the STFT round trip's
+   * error being neither added to nor removed here.
+   *
+   * The render is additive per note with no cross-note term, so an unedited note's
+   * contribution is identical between two renders. That is also the limit: a host
+   * cannot tell from two renders whether a claim set divided the energy correctly.
+   *
+   * @throws {SonareError} `InvalidParameter` on an option or an edit field the
+   *   renderer rejects — a non-positive stretch ratio, a negative or non-finite
+   *   envelope point, or a vibrato or drift edit on a note carrying no usable
+   *   pitch curve
+   */
+  render(options: PolyphonicRenderOptions = {}): Float32Array {
+    return this.handle().render(options as Record<string, unknown>);
+  }
+
+  /**
+   * Releases the underlying WASM object and everything it holds. Idempotent,
+   * as the Node facade is; any other method called after this one still
+   * throws `InvalidState` rather than reaching a freed native object.
+   */
+  delete(): void {
+    if (this.native === null) {
+      return;
+    }
+    const native = this.native;
+    this.native = null;
+    native.delete();
+  }
+
+  /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+  destroy(): void {
+    this.delete();
+  }
+}
+
+/**
+ * Analyses audio into editable notes and returns a handle to the analysis.
+ *
+ * One pass: one STFT, the multi-F0 extraction over it, a claim set per tracked
+ * ridge, the apportionment of the bins two notes stand on, and the measured fields
+ * of each note. Every note comes back with the identity edit, so rendering the
+ * result unchanged reproduces the analysis's own round trip.
+ *
+ * An analysis finding no notes is not an error. Silence, or material the register
+ * of the framing cannot resolve, tracks no ridge; rendering that is the residual
+ * alone, which is the whole round trip.
+ *
+ * **This is for spans, not for whole songs.** The handle holds the source's
+ * complex spectrogram plus every note's claimed bins — roughly 1,440 MiB for five
+ * minutes of audio against a 2 GiB linear-memory cap — so analyse the passage you
+ * are editing and {@link PolyphonicAnalysis.destroy} it when done.
+ *
+ * @throws {RangeError} on empty samples, a non-finite sample, or a `sampleRate`
+ *   outside `[8000, 384000]`
+ * @throws {SonareError} `InvalidParameter` on a config value the chain rejects,
+ *   or on audio too short for two STFT frames at the configured `nFft`/`hopLength`
+ *   (roughly one `hopLength`, ~512 samples at the default)
+ *
+ * @example
+ * ```typescript
+ * const analysis = analyzePolyphonic({ samples, sampleRate, maxPolyphony: 3 });
+ * try {
+ *   // Transpose the lowest note of the chord up a semitone.
+ *   const notes = analysis.notes();
+ *   const lowest = notes.reduce((a, b) => (a.medianHz <= b.medianHz ? a : b));
+ *   analysis.setNoteEdit(notes.indexOf(lowest), { pitchShiftSemitones: 1 });
+ *   const edited = analysis.render();
+ * } finally {
+ *   analysis.destroy();
+ * }
+ * ```
+ */
+export function analyzePolyphonic(request: AnalyzePolyphonicRequest): PolyphonicAnalysis {
+  return new PolyphonicAnalysis(request);
+}

package/src/project.ts

@@ -1,15 +1,66 @@
+export type {
+  Articulation,
+  BuiltinSynthBinding,
+  BuiltinSynthConfig,
+  BuiltinSynthWaveform,
+  ControllerAxis,
+  ControllerBinding,
+  ControllerInput,
+  MpeDimension,
+  NoteTracking,
+  SampleDesc,
+  SampleDescLoopMode,
+  SampleKeyTrack,
+  SampleLoopMode,
+  SampleZoneDesc,
+  Sf2InstrumentConfig,
+  Sf2ProgramStatus,
+  SourceBackend,
+  SynthBodyType,
+  SynthEngineMode,
+  SynthEnumTables,
+  SynthFilterModel,
+  SynthFilterOutput,
+  SynthModDestination,
+  SynthModRouting,
+  SynthModSource,
+  SynthOscWaveform,
+  SynthPatch,
+  SynthRetrigger,
+} from './instrument_types';
+export {
+  ARTICULATIONS,
+  BUILTIN_SYNTH_WAVEFORMS,
+  CONTROLLER_AXES,
+  CONTROLLER_INPUTS,
+  MPE_DIMENSIONS,
+  NOTE_TRACKINGS,
+  SAMPLE_KEY_TRACKS,
+  SAMPLE_LOOP_MODES,
+  SYNTH_BODY_TYPES,
+  SYNTH_ENGINE_MODES,
+  SYNTH_FILTER_MODELS,
+  SYNTH_FILTER_OUTPUTS,
+  SYNTH_MOD_DESTINATIONS,
+  SYNTH_MOD_SOURCES,
+  SYNTH_OSC_WAVEFORMS,
+  SYNTH_RETRIGGERS,
+} from './instrument_types';
 export { Project } from './project_class';
 export {
+  controllerProfileNames,
   projectAbiVersion,
   synthEnumTables,
+  synthGsDrumKitIsVoicedApart,
+  synthGsDrumKitName,
+  synthGsVariationIsVoicedApart,
   synthPatchRoundTripForTest,
   synthPresetNames,
   synthPresetPatch,
 } from './project_synth';
 export type {
-  BuiltinSynthBinding,
-  BuiltinSynthConfig,
-  BuiltinSynthWaveform,
+  AlignTakeToReferenceRequest,
+  AlignTakeToReferenceResult,
   ExternalSeparatedStem,
   ExternalSeparatedStemImportRequest,
   ExternalSeparatedStemImportResult,
@@ -47,41 +98,27 @@ export type {
   ProjectMidiRouteResult,
   ProjectNotePairValidation,
   ProjectSource,
+  ProjectTempoCandidate,
+  ProjectTempoOptions,
   ProjectTempoSegment,
   ProjectTimeSignatureSegment,
   ProjectTrack,
   ProjectTrackDesc,
   ProjectTrackKind,
+  ProjectTranscribeRequest,
   ProjectWarpAnchor,
   ProjectWarpMapDesc,
   ProjectWarpMode,
-  Sf2InstrumentConfig,
-  Sf2ProgramStatus,
-  SourceBackend,
-  SynthBodyType,
-  SynthEngineMode,
-  SynthEnumTables,
-  SynthFilterModel,
-  SynthFilterOutput,
-  SynthModDestination,
-  SynthModRouting,
-  SynthModSource,
-  SynthOscWaveform,
-  SynthPatch,
+  TakeAlignment,
+  TranscribeOptions,
+  TranscribeResult,
 } from './project_types';
 export {
   AutomationTargetKind,
-  BUILTIN_SYNTH_WAVEFORMS,
   EXPECTED_PROJECT_ABI_VERSION,
   MarkerKind,
   PROJECT_AUTOMATION_TARGET_OPAQUE,
   PROJECT_AUTOMATION_TARGET_TRACK_FADER_DB,
   PROJECT_AUTOMATION_TARGET_TRACK_PAN,
-  SYNTH_BODY_TYPES,
-  SYNTH_ENGINE_MODES,
-  SYNTH_FILTER_MODELS,
-  SYNTH_FILTER_OUTPUTS,
-  SYNTH_MOD_DESTINATIONS,
-  SYNTH_MOD_SOURCES,
-  SYNTH_OSC_WAVEFORMS,
 } from './project_types';
+export { SampleBank } from './sample_bank';