@libraz/libsonare 1.7.2 → 1.8.0

package/dist/playback_renderer.d.ts

@@ -0,0 +1,128 @@
+import type { PlaybackDiagnostics, PlaybackRendererConfig, PlaybackRendererOptions, RenderPlaybackRequest, RenderPlaybackResult } from './public_types_playback';
+/**
+ * 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 declare class HrtfSet {
+    private native;
+    private released;
+    private constructor();
+    /** Builds an HRTF set from SHRF v1 bytes; malformed data throws. */
+    static fromBytes(bytes: Uint8Array): HrtfSet;
+    /** Releases the native handle. Idempotent, as the Node facade is. */
+    delete(): void;
+    /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+    destroy(): void;
+}
+/**
+ * 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 declare class PlaybackRenderer {
+    private native;
+    private released;
+    constructor(options: PlaybackRendererOptions);
+    /**
+     * 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[];
+    /** Interleaved variant of {@link processPlanar}. Non-finite input samples are replaced with 0 and counted. */
+    processInterleaved(samples: Float32Array, inChannels: number): Float32Array;
+    /** Applies a complete configuration document; a changed prepare key throws. */
+    setConfig(config: PlaybackRendererConfig | string): void;
+    /** The current complete configuration document. */
+    config(): 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?: number, rollDeg?: number): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /** Channel count of the output target. */
+    outputChannels(): number;
+    /**
+     * Inactive stages, per-stage latency, clamps, the active input layout, and
+     * the layout-switch / truncated-drain counters, as a plain object.
+     */
+    diagnostics(): PlaybackDiagnostics;
+    /** Non-finite input samples replaced with 0 since construction. */
+    nonFiniteDiscardCount(): number;
+    /** Releases the native handle. Idempotent, as the Node facade is. */
+    delete(): void;
+    /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+    destroy(): void;
+}
+/**
+ * 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 declare class PlaybackLoudnessMeter {
+    private native;
+    private released;
+    constructor(channels: number, sampleRate: number);
+    /** Feeds interleaved frames of any length. */
+    pushInterleaved(samples: Float32Array): void;
+    /** Integrated loudness of everything pushed so far, in LUFS. */
+    integratedLufs(): number;
+    /** Releases the native handle. Idempotent, as the Node facade is. */
+    delete(): void;
+    /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+    destroy(): void;
+}
+/**
+ * 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 declare function renderPlayback(request: RenderPlaybackRequest): RenderPlaybackResult;
+//# sourceMappingURL=playback_renderer.d.ts.map

package/dist/playback_renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playback_renderer.d.ts","sourceRoot":"","sources":["../src/playback_renderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAsBjC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO;IAIP,oEAAoE;IACpE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAI5C,qEAAqE;IACrE,MAAM,IAAI,IAAI;IAQd,iFAAiF;IACjF,OAAO,IAAI,IAAI;CAGhB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,QAAQ,CAAS;gBAEb,OAAO,EAAE,uBAAuB;IAS5C;;;;;;;OAOG;IACH,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE;IAIrD,8GAA8G;IAC9G,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY;IAI3E,+EAA+E;IAC/E,SAAS,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,GAAG,IAAI;IAIxD,mDAAmD;IACnD,MAAM,IAAI,sBAAsB;IAIhC;;;;;OAKG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,OAAO,SAAI,GAAG,IAAI;IAInE;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACH,cAAc,IAAI,MAAM;IAIxB;;;;OAIG;IACH,aAAa,IAAI,MAAM;IAIvB,0CAA0C;IAC1C,cAAc,IAAI,MAAM;IAIxB;;;OAGG;IACH,WAAW,IAAI,mBAAmB;IAIlC,mEAAmE;IACnE,qBAAqB,IAAI,MAAM;IAI/B,qEAAqE;IACrE,MAAM,IAAI,IAAI;IAQd,iFAAiF;IACjF,OAAO,IAAI,IAAI;CAGhB;AAED;;;;GAIG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAIhD,8CAA8C;IAC9C,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C,gEAAgE;IAChE,cAAc,IAAI,MAAM;IAIxB,qEAAqE;IACrE,MAAM,IAAI,IAAI;IAQd,iFAAiF;IACjF,OAAO,IAAI,IAAI;CAGhB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,oBAAoB,CAQnF"}

package/dist/polyphony.d.ts

@@ -0,0 +1,202 @@
+import type { NoteEditInput, NoteObject, PolyphonicAnalysisOptions, PolyphonicRenderOptions } from './public_types';
+import type { ValidateOptions } 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 declare class PolyphonicAnalysis {
+    private native;
+    /** Analyses the request's audio. {@link analyzePolyphonic} is the same call. */
+    constructor(request: AnalyzePolyphonicRequest);
+    private handle;
+    /** Number of notes, which is also the number of claim sets. */
+    get noteCount(): number;
+    /** Number of STFT frames the analysis ran over. */
+    get frameCount(): number;
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /** One note's linear RMS, per frame over its own span. Indexed as {@link noteF0}. */
+    noteAmplitude(note: number): Float32Array;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+    destroy(): void;
+}
+/**
+ * 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 declare function analyzePolyphonic(request: AnalyzePolyphonicRequest): PolyphonicAnalysis;
+//# sourceMappingURL=polyphony.d.ts.map

package/dist/polyphony.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyphony.d.ts","sourceRoot":"","sources":["../src/polyphony.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,4DAA4D;AAC5D,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB,EAAE,eAAe;IAC1F,OAAO,EAAE,YAAY,CAAC;IACtB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAgC;IAE9C,gFAAgF;gBACpE,OAAO,EAAE,wBAAwB;IAW7C,OAAO,CAAC,MAAM;IAWd,+DAA+D;IAC/D,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,mDAAmD;IACnD,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;;;;;;;;;;OAWG;IACH,KAAK,IAAI,UAAU,EAAE;IAIrB;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI;IAIpD;;;;;;;OAOG;IACH,SAAS,IAAI,UAAU;IAIvB;;;;;;;;;OASG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IAIlC,qFAAqF;IACrF,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IAIzC;;;;;;;;OAQG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IAIxC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,IAAI,YAAY;IAIjC;;;;;;;;OAQG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;IAIxC;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,OAAO,GAAE,uBAA4B,GAAG,YAAY;IAI3D;;;;OAIG;IACH,MAAM,IAAI,IAAI;IASd,iFAAiF;IACjF,OAAO,IAAI,IAAI;CAGhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,kBAAkB,CAEvF"}

package/dist/project.d.ts

@@ -0,0 +1,8 @@
+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 { AlignTakeToReferenceRequest, AlignTakeToReferenceResult, ExternalSeparatedStem, ExternalSeparatedStemImportRequest, ExternalSeparatedStemImportResult, MidiCcLearnOptions, ProjectAssistSidecar, ProjectAssistSidecarInput, ProjectAutomationCurve, ProjectAutomationLaneDesc, ProjectAutomationPoint, ProjectAutomationTargetKind, ProjectBounceOptions, ProjectChordSymbol, ProjectClip, ProjectClipCompSegment, ProjectClipDesc, ProjectClipFade, ProjectClipTake, ProjectCompileResult, ProjectDeserializeResult, ProjectDiagnostic, ProjectFadeCurve, ProjectKeySegment, ProjectLoopMode, ProjectLoopRecordingDesc, ProjectLoopRecordingResult, ProjectMarker, ProjectMidiCcBinding, ProjectMidiCcBindingKind, ProjectMidiClipResult, ProjectMidiEvent, ProjectMidiFxBakeRequest, ProjectMidiFxBakeResult, ProjectMidiFxPreviewRequest, ProjectMidiRouteConfig, ProjectMidiRouteResult, ProjectNotePairValidation, ProjectSource, ProjectTempoCandidate, ProjectTempoOptions, ProjectTempoSegment, ProjectTimeSignatureSegment, ProjectTrack, ProjectTrackDesc, ProjectTrackKind, ProjectTranscribeRequest, ProjectWarpAnchor, ProjectWarpMapDesc, ProjectWarpMode, TakeAlignment, TranscribeOptions, TranscribeResult, } from './project_types';
+export { AutomationTargetKind, EXPECTED_PROJECT_ABI_VERSION, MarkerKind, PROJECT_AUTOMATION_TARGET_OPAQUE, PROJECT_AUTOMATION_TARGET_TRACK_FADER_DB, PROJECT_AUTOMATION_TARGET_TRACK_PAN, } from './project_types';
+export { SampleBank } from './sample_bank';
+//# sourceMappingURL=project.d.ts.map

package/dist/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,cAAc,GACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,eAAe,EACf,2BAA2B,EAC3B,kBAAkB,EAClB,6BAA6B,EAC7B,0BAA0B,EAC1B,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,2BAA2B,EAC3B,0BAA0B,EAC1B,qBAAqB,EACrB,kCAAkC,EAClC,iCAAiC,EACjC,kBAAkB,EAClB,oBAAoB,EACpB,yBAAyB,EACzB,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,kBAAkB,EAClB,WAAW,EACX,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,wBAAwB,EACxB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,wBAAwB,EACxB,0BAA0B,EAC1B,aAAa,EACb,oBAAoB,EACpB,wBAAwB,EACxB,qBAAqB,EACrB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,2BAA2B,EAC3B,sBAAsB,EACtB,sBAAsB,EACtB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,2BAA2B,EAC3B,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,wBAAwB,EACxB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC5B,UAAU,EACV,gCAAgC,EAChC,wCAAwC,EACxC,mCAAmC,GACpC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}