@signalsandsorcery/plugin-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1136 @@
+import React, { ComponentType, ReactNode } from 'react';
+
+/**
+ * Plugin SDK Type Definitions
+ *
+ * Complete type system for the generator plugin architecture.
+ * Plugins implement GeneratorPlugin and interact with the host via PluginHost.
+ * All plugin output flows through TracktionEngine (MIDI or audio clips).
+ */
+
+/** What kind of Tracktion content this plugin creates */
+type GeneratorType = 'midi' | 'audio' | 'sample' | 'hybrid';
+/** Describes an available instrument plugin (VST3/AU synth) on the system. */
+interface InstrumentDescriptor {
+    /** Stable plugin identifier for loading (VST3 TUID or AU component ID) */
+    pluginId: string;
+    /** Display name */
+    name: string;
+    /** Plugin manufacturer */
+    manufacturer: string;
+    /** Plugin format */
+    type: 'vst3' | 'au' | 'vst' | 'internal';
+    /** Plugin category (from scan) */
+    category: string;
+    /** Whether this plugin is currently installed/available */
+    missing?: boolean;
+}
+/** Every generator plugin must implement this interface. */
+interface GeneratorPlugin {
+    /** Unique ID, npm-style scope: '@sas/synth-generator', '@user/my-plugin' */
+    readonly id: string;
+    /** Human-readable name shown in accordion header */
+    readonly displayName: string;
+    /** Semver version string */
+    readonly version: string;
+    /** Short description for settings/marketplace */
+    readonly description: string;
+    /** 24x24 icon — data URL, relative path from plugin dir, or undefined */
+    readonly icon?: string;
+    /** What kind of Tracktion content this plugin creates */
+    readonly generatorType: GeneratorType;
+    /** Minimum host SDK version this plugin requires */
+    readonly minHostVersion?: string;
+    /**
+     * Called once when plugin is loaded. Receives the PluginHost API.
+     * If this throws, plugin is marked as failed and not rendered.
+     */
+    activate(host: PluginHost): Promise<void>;
+    /**
+     * Called when plugin is being unloaded (disable, uninstall, app quit).
+     * Must complete within 5 seconds or host force-kills.
+     */
+    deactivate(): Promise<void>;
+    /**
+     * Return the React component rendered inside the accordion section.
+     * Component receives PluginUIProps from the host.
+     */
+    getUIComponent(): ComponentType<PluginUIProps>;
+    /**
+     * Return JSON Schema for plugin-specific settings.
+     * Host auto-renders a settings form. Return null if no settings.
+     */
+    getSettingsSchema(): PluginSettingsSchema | null;
+    /**
+     * Optional: Called when the active scene changes.
+     */
+    onSceneChanged?(sceneId: string | null): Promise<void>;
+    /**
+     * Optional: Called when the generation context changes
+     * (chords updated, tracks added/removed, BPM changed).
+     */
+    onContextChanged?(context: MusicalContext): void;
+}
+/** Props passed to every plugin's React component by the host */
+interface PluginUIProps {
+    /** The scoped PluginHost API instance for this plugin */
+    host: PluginHost;
+    /** Currently active scene ID (null if none selected) */
+    activeSceneId: string | null;
+    /** Whether the user is authenticated (for LLM access) */
+    isAuthenticated: boolean;
+    /** Whether all systems are connected (engine, gateway) */
+    isConnected: boolean;
+    /** Which workstation deck this is rendered in */
+    deckId?: 'left' | 'right';
+    /** Plugin calls this to set/clear header buttons. Pass null to clear. */
+    onHeaderContent?: (content: ReactNode | null) => void;
+    /** Plugin calls this to show/hide the loading spinner in the header. */
+    onLoading?: (loading: boolean) => void;
+    /** Scene-level context: contract state, chords, BPM, etc. Null if no scene. */
+    sceneContext?: PluginSceneContext | null;
+    /** Callback to open the scene selector (Scenes accordion section). */
+    onSelectScene?: (() => void) | null;
+    /** Callback to open the contract/chords section (for "Generate a Contract" CTA). */
+    onOpenContract?: (() => void) | null;
+    /** Callback to expand this plugin's own accordion section. */
+    onExpandSelf?: (() => void) | null;
+}
+/** Scoped API surface that plugins interact with. Plugins NEVER get direct TracktionEngine access. */
+interface PluginHost {
+    /** Create a new track in the active scene. Host enforces ownership and scene routing. */
+    createTrack(options: CreateTrackOptions): Promise<PluginTrackHandle>;
+    /** Delete a track previously created by THIS plugin. */
+    deleteTrack(trackId: string): Promise<void>;
+    /** Get all tracks this plugin owns in the active scene. */
+    getPluginTracks(): Promise<PluginTrackHandle[]>;
+    /** Adopt unowned tracks in the active scene matching this plugin's generator type. */
+    adoptSceneTracks(): Promise<PluginTrackHandle[]>;
+    /** Get info about a specific owned track. */
+    getTrackInfo(trackId: string): Promise<PluginTrackInfo>;
+    /** Set track mute state. Only works on owned tracks. */
+    setTrackMute(trackId: string, muted: boolean): Promise<void>;
+    /** Set track volume (linear 0.0 - 1.0). Only works on owned tracks. */
+    setTrackVolume(trackId: string, volume: number): Promise<void>;
+    /** Set track pan (-1.0 left to 1.0 right). Only works on owned tracks. */
+    setTrackPan(trackId: string, pan: number): Promise<void>;
+    /** Set track solo state. Only works on owned tracks. */
+    setTrackSolo(trackId: string, solo: boolean): Promise<void>;
+    /** Rename a track. Only works on owned tracks. */
+    setTrackName(trackId: string, name: string): Promise<void>;
+    /** Shuffle preset: keep MIDI, apply a random preset from the same category. Only works on owned tracks. */
+    shufflePreset(trackId: string): Promise<ShufflePresetResult>;
+    /** Duplicate track: copy MIDI + role to a new track with a different preset. Only works on owned tracks. */
+    duplicateTrack(trackId: string): Promise<PluginTrackHandle>;
+    /** Get detailed FX state for a track (enabled, preset, dry/wet per category). */
+    getTrackFxState(trackId: string): Promise<PluginTrackFxDetailState>;
+    /** Toggle an FX category on/off for a track. */
+    toggleTrackFx(trackId: string, category: string, enabled: boolean): Promise<void>;
+    /** Set FX preset for a track. Returns the new dry/wet value if applicable. */
+    setTrackFxPreset(trackId: string, category: string, presetIndex: number): Promise<{
+        dryWet?: number;
+    }>;
+    /** Set FX dry/wet level for a track. */
+    setTrackFxDryWet(trackId: string, category: string, value: number): Promise<void>;
+    /** Subscribe to real-time track state changes (mute, solo, volume, pan). Returns unsubscribe fn. */
+    onTrackStateChange(listener: TrackStateChangeListener): UnsubscribeFn;
+    /** Write MIDI notes to a track this plugin owns. Replaces existing MIDI. */
+    writeMidiClip(trackId: string, clip: MidiClipData): Promise<MidiWriteResult>;
+    /** Clear all MIDI from a track this plugin owns. */
+    clearMidi(trackId: string): Promise<void>;
+    /**
+     * Run the host's MIDI post-processing pipeline on raw notes.
+     * Wraps MidiProcessor: quantize -> swing -> scale -> register -> overlaps -> humanize.
+     */
+    postProcessMidi(notes: PluginMidiNote[], options: PostProcessOptions): Promise<PluginMidiNote[]>;
+    /** Place an audio file on a track this plugin owns. */
+    writeAudioClip(trackId: string, filePath: string, position?: number): Promise<void>;
+    /** Load a VST3/AU plugin onto a track this plugin owns. */
+    loadSynthPlugin(trackId: string, pluginName: string): Promise<number>;
+    /** Set plugin state (base64-encoded preset data). */
+    setPluginState(trackId: string, pluginIndex: number, stateBase64: string): Promise<void>;
+    /** Get current plugin state (base64-encoded). */
+    getPluginState(trackId: string, pluginIndex: number): Promise<string>;
+    /** List plugins currently loaded on a track. */
+    getTrackPlugins(trackId: string): Promise<PluginSynthInfo[]>;
+    /** Remove a plugin from a track. */
+    removePlugin(trackId: string, pluginIndex: number): Promise<void>;
+    /** Check if a specific VST/AU plugin is available on the system. */
+    isPluginAvailable(pluginName: string): Promise<boolean>;
+    /** Get available instrument plugins (VST3/AU synths) scanned by the engine. */
+    getAvailableInstruments(): Promise<InstrumentDescriptor[]>;
+    /** Get the instrument plugin currently loaded on a track. Null = default (Surge XT). */
+    getTrackInstrument(trackId: string): Promise<InstrumentDescriptor | null>;
+    /** Change the instrument plugin on a track. Preserves MIDI data. */
+    setTrackInstrument(trackId: string, pluginId: string): Promise<void>;
+    /** Get the FULL generation context for the active scene. */
+    getGenerationContext(excludeTrackId?: string): Promise<PluginGenerationContext>;
+    /** Get lightweight musical context (no concurrent track MIDI data). */
+    getMusicalContext(): Promise<MusicalContext>;
+    /** Get the active scene ID. Null if no scene is active. */
+    getActiveSceneId(): string | null;
+    /** Get list of all scenes in the project. */
+    getSceneList(): Promise<PluginSceneInfo[]>;
+    /** Subscribe to transport state changes. Returns unsubscribe function. */
+    onTransportEvent(listener: TransportEventListener): UnsubscribeFn;
+    /** Subscribe to deck boundary events. Returns unsubscribe function. */
+    onDeckBoundary(listener: DeckBoundaryListener): UnsubscribeFn;
+    /** Subscribe to scene change events. Returns unsubscribe function. */
+    onSceneChange(listener: SceneChangeListener): UnsubscribeFn;
+    /** Get current transport state (one-shot). */
+    getTransportState(): Promise<PluginTransportState>;
+    /** Generate text/JSON via the host's authenticated LLM service. */
+    generateWithLLM(request: LLMGenerationRequest): Promise<LLMGenerationResult>;
+    /** Check if LLM access is available (user authenticated + gateway reachable). */
+    isLLMAvailable(): Promise<boolean>;
+    /** Get available preset categories for a synth plugin. */
+    getPresetCategories(pluginName: string): Promise<string[]>;
+    /** Get a random preset from a category. */
+    getRandomPreset(category: string): Promise<PluginPresetData | null>;
+    /** Get a specific preset by name from a category. */
+    getPresetByName(category: string, name: string): Promise<PluginPresetData | null>;
+    /** Use LLM to classify a text description into a preset category. */
+    classifyPresetCategory(description: string): Promise<string>;
+    /** Get absolute path to this plugin's isolated data directory. */
+    getDataDirectory(): string;
+    /** Persisted key-value settings store. */
+    settings: PluginSettingsStore;
+    /** Get a value from scene-scoped plugin data. */
+    getSceneData<T = unknown>(sceneId: string, key: string): Promise<T | null>;
+    /** Set a value in scene-scoped plugin data. */
+    setSceneData(sceneId: string, key: string, value: unknown): Promise<void>;
+    /** Get all key-value pairs for a scene. */
+    getAllSceneData(sceneId: string): Promise<Record<string, unknown>>;
+    /** Delete a key from scene-scoped plugin data. */
+    deleteSceneData(sceneId: string, key: string): Promise<void>;
+    /** Get the full project-scoped state object. */
+    getProjectData<T = unknown>(key: string): Promise<T | null>;
+    /** Set a project-scoped data value. */
+    setProjectData(key: string, value: unknown): Promise<void>;
+    /** Show a toast notification to the user. */
+    showToast(type: 'info' | 'success' | 'warning' | 'error', title: string, message?: string): void;
+    /** Set progress indicator on a specific track. -1 to hide. */
+    setProgress(trackId: string, progress: number): void;
+    /** Set a global status message in the plugin's accordion header. */
+    setStatusMessage(message: string | null): void;
+    /** Request user confirmation via a modal dialog. */
+    confirmAction(title: string, message: string): Promise<boolean>;
+    /** Show a native file open dialog. Requires 'fileDialog' capability. */
+    showOpenDialog(options: PluginFileDialogOptions): Promise<string[] | null>;
+    /** Show a native file save dialog. Requires 'fileDialog' capability. */
+    showSaveDialog(options: PluginFileDialogOptions): Promise<string | null>;
+    /** Download a file to the plugin's data directory. */
+    downloadFile(url: string, filename: string, options?: PluginDownloadOptions): Promise<string>;
+    /** Copy a file into the plugin's data directory. */
+    importFile(sourcePath: string, destFilename: string): Promise<string>;
+    /** Make an HTTP request. Requires 'network' capability with allowedHosts. */
+    httpRequest(options: PluginHttpRequestOptions): Promise<PluginHttpResponse>;
+    /** Store a secret in the OS keychain (plugin-scoped). */
+    storeSecret(key: string, value: string): Promise<void>;
+    /** Retrieve a secret from the OS keychain (plugin-scoped). */
+    getSecret(key: string): Promise<string | null>;
+    /** Delete a secret from the OS keychain (plugin-scoped). */
+    deleteSecret(key: string): Promise<void>;
+    /** Query the sample library with optional filters. */
+    getSamples(filter?: PluginSampleFilter): Promise<PluginSampleInfo[]>;
+    /** Get a single sample by ID. */
+    getSampleById(id: string): Promise<PluginSampleInfo | null>;
+    /** Import audio files into the sample library. */
+    importSamples(filePaths: string[]): Promise<PluginSampleImportResult>;
+    /** Create a sample track in the active scene. */
+    createSampleTrack(sampleId: string, options?: {
+        name?: string;
+    }): Promise<PluginTrackHandle>;
+    /** Delete a sample track. */
+    deleteSampleTrack(trackId: string): Promise<void>;
+    /** Get all sample tracks in the active scene. Re-establishes ownership. */
+    getPluginSampleTracks(): Promise<PluginSampleTrackInfo[]>;
+    /** Time-stretch a sample to a target BPM. Returns the new sample info. */
+    timeStretchSample(sampleId: string, targetBpm: number): Promise<PluginSampleInfo>;
+    /** Invoke the host's audio texture generation pipeline. */
+    generateAudioTexture(request: PluginAudioTextureRequest): Promise<PluginAudioTextureResult>;
+    /** Trigger bulk composition for the active scene (LLM plans arrangement, creates tracks, generates MIDI). */
+    composeScene(options: ComposeSceneOptions): Promise<ComposeSceneResult>;
+    /** Subscribe to composition progress events (planning, generating, complete, error). */
+    onComposeProgress(listener: ComposeProgressListener): UnsubscribeFn;
+    /** Subscribe to engine ready events (fires when the engine finishes loading tracks after a scene change). */
+    onEngineReady(listener: () => void): UnsubscribeFn;
+    /** Audition a single note on a track (fire-and-forget preview). */
+    auditionNote(trackId: string, pitch: number, velocity: number, durationMs: number): Promise<void>;
+    /** Get presets for this plugin, optionally filtered by category. */
+    getPluginPresets(category?: string): Promise<PluginPresetInfo[]>;
+    /** Save a new preset for this plugin. */
+    savePluginPreset(options: SavePluginPresetOptions): Promise<PluginPresetInfo>;
+    /** Delete a plugin preset by ID. */
+    deletePluginPreset(id: string): Promise<void>;
+    /** Log a performance metric. */
+    logMetric(name: string, durationMs: number, metadata?: Record<string, unknown>): void;
+    /** Start a timer. Returns a stop function that logs the duration. */
+    startTimer(name: string): () => void;
+}
+interface ExportedPluginData {
+    pluginId: string;
+    scope: 'project' | 'scene' | 'global';
+    scopeId: string | null;
+    key: string;
+    value: string;
+}
+interface CreateTrackOptions {
+    /** Display name for the track. Auto-generated if omitted. */
+    name?: string;
+    /** Musical role hint: 'bass', 'drums', 'lead', 'chords', 'pad', 'arp', 'fx' */
+    role?: string;
+    /** Load a synth plugin immediately (default: false) */
+    loadSynth?: boolean;
+    /** Which synth to load (default: 'Surge XT'). Ignored if loadSynth=false. */
+    synthName?: string;
+    /**
+     * Stable plugin identifier for a custom instrument (VST3 TUID or AU component ID).
+     * If provided with loadSynth=true, loads this plugin instead of synthName.
+     * Null/undefined = use default (Surge XT).
+     */
+    instrumentPluginId?: string | null;
+    /** Metadata stored in DB. Plugins can use this for plugin-specific data. */
+    metadata?: Record<string, unknown>;
+}
+interface PluginTrackHandle {
+    /** Tracktion engine track ID (stable, GUID-based) */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Database row ID */
+    dbId: string;
+    /** Musical role (if set) */
+    role?: string;
+    /** Prompt from tracks table (fallback when plugin_data not yet populated) */
+    prompt?: string;
+    /** Custom instrument plugin ID (null = default Surge XT) */
+    instrumentPluginId?: string | null;
+    /** Custom instrument display name (null = Surge XT) */
+    instrumentName?: string | null;
+}
+interface PluginTrackInfo extends PluginTrackHandle {
+    /** Is track muted? */
+    muted: boolean;
+    /** Is track soloed? */
+    soloed: boolean;
+    /** Volume (linear 0-1) */
+    volume: number;
+    /** Pan (-1 to 1) */
+    pan: number;
+    /** Loaded plugins on this track */
+    plugins: PluginSynthInfo[];
+    /** Has MIDI clips? */
+    hasMidi: boolean;
+    /** Has audio clips? */
+    hasAudio: boolean;
+}
+interface PluginSynthInfo {
+    index: number;
+    name: string;
+    type: string;
+    enabled: boolean;
+}
+/** Real-time runtime state of a track (pushed from engine) */
+interface PluginTrackRuntimeState {
+    id: string;
+    muted: boolean;
+    solo: boolean;
+    volume: number;
+    pan: number;
+}
+/** Listener for real-time track state changes */
+type TrackStateChangeListener = (trackId: string, state: PluginTrackRuntimeState) => void;
+/** Per-category FX detail state */
+interface PluginFxCategoryDetailState {
+    enabled: boolean;
+    presetIndex: number;
+    dryWet: number;
+}
+/** Full FX detail state for a track — one entry per FX category */
+type PluginTrackFxDetailState = Record<string, PluginFxCategoryDetailState>;
+interface MidiClipData {
+    /** Start time in seconds */
+    startTime: number;
+    /** End time in seconds */
+    endTime: number;
+    /** BPM for beat<->time conversion */
+    tempo: number;
+    /** MIDI notes */
+    notes: PluginMidiNote[];
+}
+interface PluginMidiNote {
+    /** MIDI pitch 0-127 */
+    pitch: number;
+    /** Start position in quarter-note beats (0 = beginning of clip) */
+    startBeat: number;
+    /** Duration in quarter-note beats */
+    durationBeats: number;
+    /** Velocity 1-127 */
+    velocity: number;
+    /** MIDI channel 0-15 (default: 0) */
+    channel?: number;
+}
+interface MidiWriteResult {
+    /** Number of notes written */
+    notesInserted: number;
+    /** Actual bars covered */
+    bars: number;
+}
+interface PostProcessOptions {
+    /** Snap notes to grid (default: true) */
+    quantize?: boolean;
+    /** Grid size: '1/4', '1/8', '1/16', '1/32', '1/8T', '1/16T' (default: '1/16') */
+    quantizeGrid?: string;
+    /** Quantize strength 0-100 (default: 75) */
+    quantizeStrength?: number;
+    /** Swing amount 0-100 (default: 0) */
+    swing?: number;
+    /** Humanize timing/velocity variation 0-100 (default: 0) */
+    humanize?: number;
+    /** Enforce diatonic scale (default: false). Uses scene key/mode. */
+    enforceScale?: boolean;
+    /** Clamp notes to pitch range [low, high] */
+    clampRegister?: [number, number];
+    /** Remove overlapping notes on same pitch/channel (default: true) */
+    removeOverlaps?: boolean;
+}
+interface MusicalContext {
+    key: string;
+    mode: string;
+    bpm: number;
+    bars: number;
+    genre: string | null;
+    timeSignature: string;
+    chordProgression: PluginChordTiming[];
+}
+interface PluginChordTiming {
+    /** Chord symbol: 'Cm7', 'G', 'Fmaj7', etc. */
+    symbol: string;
+    /** Start position in quarter notes */
+    startQn: number;
+    /** End position in quarter notes */
+    endQn: number;
+}
+/** Full generation context — includes concurrent track MIDI data */
+interface PluginGenerationContext {
+    chordProgression: {
+        key: {
+            tonic: string;
+            mode: string;
+        };
+        chordsWithTiming: PluginChordTiming[];
+        genre: string | null;
+    };
+    concurrentTracks: PluginConcurrentTrackInfo[];
+}
+interface PluginConcurrentTrackInfo {
+    trackId: string;
+    role: string | undefined;
+    presetCategory: string | null;
+    /** Notes organized by which chord they fall under */
+    notesByChord: PluginChordSegment[];
+}
+interface PluginChordSegment {
+    chord: string;
+    chordRangeQn: [number, number];
+    notes: PluginMidiNote[];
+}
+interface TransportEvent {
+    type: 'play' | 'stop' | 'pause' | 'bpmChange' | 'positionChange';
+    bpm?: number;
+    position?: number;
+    isPlaying?: boolean;
+}
+interface DeckBoundaryEvent {
+    deckId: string;
+    bar: number;
+    beat: number;
+    loopCount: number;
+}
+interface PluginTransportState {
+    isPlaying: boolean;
+    isPaused: boolean;
+    bpm: number;
+    position: number;
+    timeSignature: string;
+}
+interface PluginSceneInfo {
+    id: string;
+    name: string;
+    isMuted: boolean;
+}
+/** Scene-level contract/context state passed to plugin UIs as a prop */
+interface PluginSceneContext {
+    /** Whether a contract has been generated (genre or contractPrompt exists AND chords exist) */
+    hasContract: boolean;
+    /** Original user prompt text (e.g., "dark psytrance"). Null if none. */
+    contractPrompt: string | null;
+    /** Extracted genre. Null if none. */
+    genre: string | null;
+    /** Musical key. Null if no chord progression. */
+    key: {
+        tonic: string;
+        mode: string;
+    } | null;
+    /** Chord symbols (e.g., ["Cm", "Fm", "G"]). Empty if no chords. */
+    chords: string[];
+    /** BPM from project tempo */
+    bpm: number;
+    /** Scene length in bars */
+    bars: number;
+    /** Whether any synth tracks exist in this scene */
+    hasTracks: boolean;
+    /** Whether bulk generation is currently in progress */
+    isBulkGenerating: boolean;
+}
+/** Placeholder track state for the progressive bulk-add UX */
+interface BulkAddPlaceholderTrack {
+    id: string;
+    planIndex: number;
+    role: string;
+    description: string;
+    status: 'planned' | 'creating' | 'completed' | 'failed';
+    error?: string;
+}
+type TransportEventListener = (event: TransportEvent) => void;
+type DeckBoundaryListener = (event: DeckBoundaryEvent) => void;
+type SceneChangeListener = (sceneId: string | null) => void;
+type UnsubscribeFn = () => void;
+interface LLMGenerationRequest {
+    /** System prompt (instructions, role, output format) */
+    system: string;
+    /** User prompt (the actual request) */
+    user: string;
+    /** Max tokens for response (host may cap this) */
+    maxTokens?: number;
+    /** Expected response format hint */
+    responseFormat?: 'text' | 'json';
+    /**
+     * If true, the host will NOT auto-prefix the user prompt with musical
+     * context (key, BPM, chords, genre, etc.). Default: false (context IS
+     * prefixed automatically).
+     */
+    skipContextPrefix?: boolean;
+}
+interface LLMGenerationResult {
+    /** Raw response text */
+    content: string;
+    /** Tokens consumed */
+    tokensUsed: number;
+    /** Model that generated the response */
+    model: string;
+}
+interface PluginPresetData {
+    name: string;
+    category: string;
+    /** Base64-encoded plugin state — pass to setPluginState() */
+    state: string;
+}
+/** Result of shufflePreset() — the new preset that was applied */
+interface ShufflePresetResult {
+    presetName: string;
+    presetCategory: string;
+}
+interface PluginSettingsSchema {
+    type: 'object';
+    properties: Record<string, SettingDefinition>;
+}
+interface SettingDefinition {
+    type: 'string' | 'number' | 'boolean' | 'select';
+    label: string;
+    description?: string;
+    default?: unknown;
+    /** For 'select' type */
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    /** For 'number' type */
+    min?: number;
+    max?: number;
+}
+interface PluginSettingsStore {
+    get<T>(key: string, defaultValue: T): T;
+    set(key: string, value: unknown): void;
+    getAll(): Record<string, unknown>;
+    /** Subscribe to settings changes. Returns unsubscribe fn. */
+    onChange(listener: (key: string, value: unknown) => void): UnsubscribeFn;
+}
+type PluginErrorCode = 'NOT_OWNED' | 'TRACK_NOT_FOUND' | 'TRACK_LIMIT_EXCEEDED' | 'NO_ACTIVE_SCENE' | 'ENGINE_ERROR' | 'INVALID_MIDI' | 'FILE_NOT_FOUND' | 'INVALID_FORMAT' | 'PLUGIN_NOT_FOUND' | 'LLM_BUDGET_EXCEEDED' | 'LLM_UNAVAILABLE' | 'NOT_AUTHENTICATED' | 'TIMEOUT' | 'CANCELLED' | 'INCOMPATIBLE' | 'CAPABILITY_DENIED' | 'SECRET_NOT_FOUND';
+declare class PluginError extends Error {
+    readonly code: PluginErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(code: PluginErrorCode, message: string, details?: Record<string, unknown>);
+}
+interface PluginManifest {
+    id: string;
+    displayName: string;
+    version: string;
+    description: string;
+    generatorType: GeneratorType;
+    main: string;
+    renderer?: string;
+    icon?: string;
+    author?: string;
+    license?: string;
+    minHostVersion?: string;
+    capabilities?: PluginCapabilities;
+    settings?: Record<string, SettingDefinition>;
+    builtIn?: boolean;
+    repository?: string;
+}
+interface PluginCapabilities {
+    requiresLLM?: boolean;
+    requiresSurgeXT?: boolean;
+    requiresNetwork?: boolean;
+    /** Allowed network hosts for httpRequest (e.g., ['api.splice.com']) */
+    network?: {
+        allowedHosts?: string[];
+    };
+    /** Plugin needs native file dialog access */
+    fileDialog?: boolean;
+}
+interface PluginFileDialogOptions {
+    title?: string;
+    defaultPath?: string;
+    filters?: Array<{
+        name: string;
+        extensions: string[];
+    }>;
+    /** For open dialog: allow selecting multiple files */
+    multiSelections?: boolean;
+    /** For open dialog: allow selecting directories */
+    directories?: boolean;
+}
+interface PluginDownloadOptions {
+    /** HTTP headers to include */
+    headers?: Record<string, string>;
+    /** Overwrite if file exists (default: false) */
+    overwrite?: boolean;
+}
+interface PluginHttpRequestOptions {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: string | Record<string, unknown>;
+    /** Timeout in milliseconds (default: 30000) */
+    timeoutMs?: number;
+}
+interface PluginHttpResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+interface PluginSampleFilter {
+    bpm?: number;
+    key?: {
+        tonic: string;
+        mode?: string;
+    };
+    category?: string;
+    searchQuery?: string;
+}
+interface PluginSampleInfo {
+    id: string;
+    filename: string;
+    filePath: string;
+    category: string | null;
+    bpm: number | null;
+    keyTonic: string | null;
+    keyMode: string | null;
+    durationSeconds: number | null;
+    fileSizeBytes: number | null;
+    tags: string[] | null;
+}
+interface PluginSampleImportResult {
+    imported: number;
+    skipped: number;
+    errors: string[];
+}
+/** Sample track with associated sample metadata (returned by getPluginSampleTracks) */
+interface PluginSampleTrackInfo {
+    track: PluginTrackHandle;
+    sample: PluginSampleInfo;
+    volume: number;
+    pan: number;
+}
+interface PluginAudioTextureRequest {
+    /** Text prompt describing the audio texture */
+    prompt: string;
+    /** Duration in seconds (default: scene length) */
+    durationSeconds?: number;
+    /** Target BPM (default: project BPM) */
+    bpm?: number;
+}
+interface PluginAudioTextureResult {
+    /** Path to the generated audio file */
+    filePath: string;
+    /** Duration of the generated audio in seconds */
+    durationSeconds: number;
+}
+/** Options for composing a full scene arrangement via LLM. */
+interface ComposeSceneOptions {
+    /** The contract prompt / musical direction for the arrangement. */
+    contractPrompt: string;
+    /** Genre hint (e.g. 'techno', 'jazz'). Optional. */
+    genre?: string | null;
+}
+/** Result from a scene composition. */
+interface ComposeSceneResult {
+    /** Whether the composition completed successfully. */
+    success: boolean;
+    /** Number of tracks created. */
+    tracksCreated: number;
+    /** Error message if not successful. */
+    error?: string;
+}
+/** Listener for composition progress events. */
+type ComposeProgressListener = (event: ComposeProgressEvent) => void;
+/** Progress event emitted during scene composition. */
+interface ComposeProgressEvent {
+    /** Current phase: 'planning' (LLM deciding tracks), 'generating' (creating MIDI), 'complete', 'error'. */
+    phase: 'planning' | 'generating' | 'complete' | 'error';
+    /** Per-track placeholder state (available once planning is done). */
+    placeholders?: BulkAddPlaceholderTrack[];
+    /** Error message when phase is 'error'. */
+    error?: string;
+    /** Scene ID this compose event belongs to (for scene-keyed UI state). */
+    sceneId?: string;
+}
+interface PluginPresetInfo {
+    id: string;
+    name: string;
+    category: string | null;
+    isBuiltIn: boolean;
+    data: Record<string, unknown>;
+}
+interface SavePluginPresetOptions {
+    name: string;
+    category?: string;
+    data: Record<string, unknown>;
+}
+type PluginStatus = 'pending' | 'active' | 'failed' | 'disabled' | 'incompatible';
+interface PluginRegistration {
+    /** The loaded plugin instance */
+    plugin: GeneratorPlugin;
+    /** Current status */
+    status: PluginStatus;
+    /** Resolved manifest from disk */
+    manifest: PluginManifest;
+    /** The scoped PluginHost instance for this plugin */
+    host: PluginHost | null;
+    /** Sort order for accordion display */
+    sortOrder: number;
+    /** Whether the plugin is enabled */
+    enabled: boolean;
+    /** Error message if status is 'failed' */
+    error?: string;
+}
+
+/**
+ * FX Toggle Types
+ *
+ * Types and constants for per-track FX toggle buttons.
+ * Each track can enable/disable 6 FX categories independently.
+ * The engine is the source of truth — no database persistence needed.
+ */
+/** Available FX categories in signal chain order */
+type FxCategory = 'eq' | 'compressor' | 'chorus' | 'phaser' | 'delay' | 'reverb';
+/** All FX categories in signal chain order */
+declare const FX_CATEGORIES: readonly FxCategory[];
+/** Position in the signal chain (lower = earlier) */
+declare const FX_CHAIN_ORDER: Record<FxCategory, number>;
+/** Map from FxCategory to Tracktion Engine built-in plugin xmlTypeName */
+declare const FX_ENGINE_PLUGIN_NAMES: Record<FxCategory, string>;
+/** Display labels for UI buttons */
+declare const FX_DISPLAY_LABELS: Record<FxCategory, string>;
+/** Per-track FX state: which categories are active */
+interface TrackFxState {
+    eq: boolean;
+    compressor: boolean;
+    chorus: boolean;
+    phaser: boolean;
+    delay: boolean;
+    reverb: boolean;
+}
+/** Default state: all FX disabled */
+declare const EMPTY_FX_STATE: TrackFxState;
+/** A single FX preset definition */
+interface FxPreset {
+    /** Display name (e.g. "Room", "Hall") */
+    name: string;
+    /** Short label for button (e.g. "RM", "HL") */
+    shortLabel: string;
+    /** Map from automatable parameter name -> value (set via setPluginParameter) */
+    params: Record<string, number>;
+    /** CachedValue params set via XML state (getPluginState/setPluginState) */
+    xmlStateParams?: Record<string, number>;
+    /** BPM-relative delay time multiplier (1.0 = quarter note). When set, Delay Time is computed at apply time. */
+    noteMultiplier?: number;
+    /** Fixed delay time in ms (non-BPM-synced). Mutually exclusive with noteMultiplier. */
+    fixedLengthMs?: number;
+}
+/** How dry/wet is applied to the plugin */
+type MixInterpolation = 'direct' | 'gain-scale' | 'ratio-scale';
+/** Preset configuration for an FX category */
+interface FxPresetConfig {
+    /** Exactly 5 presets */
+    presets: [FxPreset, FxPreset, FxPreset, FxPreset, FxPreset];
+    /** Name of the native mix/wet parameter, or null if no native dry/wet */
+    mixParamName: string | null;
+    /** XML attribute name for dry/wet control (for plugins with no automatable mix param, e.g. chorus/phaser) */
+    mixXmlAttr?: string;
+    /** How to apply dry/wet (defaults to 'direct') */
+    mixInterpolation: MixInterpolation;
+}
+/** Per-category detail state for a single FX on a track */
+interface FxCategoryDetailState {
+    enabled: boolean;
+    presetIndex: number;
+    dryWet: number;
+}
+/** Extended FX state per track with preset and dry/wet info */
+type TrackFxDetailState = Record<FxCategory, FxCategoryDetailState>;
+/** Default dry/wet mix level (33% — musically useful for most effects) */
+declare const DEFAULT_FX_DRY_WET = 0.33;
+/** Default detail state for a single category */
+declare const DEFAULT_FX_CATEGORY_DETAIL: FxCategoryDetailState;
+/** Default detail state: all FX disabled, preset 0, full wet */
+declare const EMPTY_FX_DETAIL_STATE: TrackFxDetailState;
+/** Persisted FX data for a single category (stored as JSON in database) */
+interface FxPresetDataEntry {
+    presetIndex: number;
+    dryWet: number;
+    enabled: boolean;
+}
+/** Persisted FX data format (stored as JSON in database) */
+type FxPresetData = Partial<Record<FxCategory, FxPresetDataEntry>>;
+
+/**
+ * SDK TrackRow — Reusable track row component for generator plugins.
+ *
+ * Renders a complete track UI with prompt input, generation controls,
+ * shuffle/copy, volume/pan, mute/solo, FX drawer, and visual states
+ * (amber pulse for "needs generation", progress overlay, error indicator).
+ *
+ * Layout matches TrackInput (main branch) for visual parity.
+ *
+ * Depends only on PluginHost types + existing shared renderer components.
+ */
+
+interface SDKTrackRowProps {
+    /** Track identity */
+    track: {
+        id: string;
+        name: string;
+        role?: string;
+    };
+    /** Current prompt text (optional — omit when using contentSlot) */
+    prompt?: string;
+    /** Playback state */
+    runtimeState: {
+        muted: boolean;
+        solo: boolean;
+        volume: number;
+        pan: number;
+    };
+    /** FX category states */
+    fxDetailState: TrackFxDetailState;
+    /** FX panel visibility */
+    fxDrawerOpen: boolean;
+    /** Generation in progress */
+    isGenerating?: boolean;
+    /** Auth state */
+    isAuthenticated?: boolean;
+    /** Error from last generation */
+    error?: string | null;
+    /** Enables shuffle/copy buttons */
+    hasMidi?: boolean;
+    /** Progress % (for persistence across scene switches) */
+    generationProgress?: number;
+    /** For progress bar pacing */
+    estimatedGenerationMs?: number;
+    /** Prompt edit (optional — omit to hide prompt input) */
+    onPromptChange?: (prompt: string) => void;
+    /** "Create" button / Enter key (optional — omit to hide Create button) */
+    onGenerate?: () => void;
+    /** Shuffle preset (optional — omit to hide Shuffle button) */
+    onShuffle?: () => void;
+    /** Duplicate track (optional — omit to hide Copy button) */
+    onCopy?: () => void;
+    /** Delete track */
+    onDelete: () => void;
+    /** Custom content replacing the prompt input (e.g., sample info display) */
+    contentSlot?: React.ReactNode;
+    /** Toggle mute */
+    onMuteToggle: () => void;
+    /** Toggle solo */
+    onSoloToggle: () => void;
+    /** Volume slider */
+    onVolumeChange: (vol: number) => void;
+    /** Pan slider */
+    onPanChange: (pan: number) => void;
+    /** FX category toggle (optional — omit to hide FX button) */
+    onFxToggle?: (cat: FxCategory, enabled: boolean) => void;
+    /** FX preset select */
+    onFxPresetChange?: (cat: FxCategory, idx: number) => void;
+    /** FX dry/wet */
+    onFxDryWetChange?: (cat: FxCategory, val: number) => void;
+    /** Open/close FX (optional — omit to hide FX button) */
+    onToggleFxDrawer?: () => void;
+    /** Progress persistence callback */
+    onProgressChange?: (pct: number) => void;
+    /** Left border accent color */
+    accentColor?: string;
+    /** Current instrument display name (null/undefined = Surge XT default) */
+    instrumentName?: string | null;
+    /** Whether the current instrument plugin is missing from the system */
+    instrumentMissing?: boolean;
+    /** Whether the instrument drawer is open */
+    instrumentDrawerOpen?: boolean;
+    /** Toggle the instrument drawer */
+    onToggleInstrumentDrawer?: () => void;
+    /** Available instrument plugins for the drawer */
+    availableInstruments?: InstrumentDescriptor[];
+    /** Currently loaded instrument plugin ID */
+    currentInstrumentPluginId?: string | null;
+    /** Called when user selects an instrument from the drawer */
+    onInstrumentSelect?: (pluginId: string) => void;
+    /** Whether instrument scan is loading */
+    instrumentsLoading?: boolean;
+    /** Re-scan for instruments */
+    onRefreshInstruments?: () => void;
+}
+declare function TrackRow({ track, prompt, runtimeState, fxDetailState, fxDrawerOpen, isGenerating, isAuthenticated, error, hasMidi, generationProgress, estimatedGenerationMs, onPromptChange, onGenerate, onShuffle, onCopy, onDelete, contentSlot, onMuteToggle, onSoloToggle, onVolumeChange, onPanChange, onFxToggle, onFxPresetChange, onFxDryWetChange, onToggleFxDrawer, onProgressChange, accentColor, instrumentName, instrumentMissing, instrumentDrawerOpen, onToggleInstrumentDrawer, availableInstruments, currentInstrumentPluginId, onInstrumentSelect, instrumentsLoading, onRefreshInstruments, }: SDKTrackRowProps): React.ReactElement;
+
+/**
+ * InstrumentDrawer — Sliding drawer for selecting instrument plugins (VST3/AU).
+ *
+ * Appears below the track controls when the "P" button is toggled.
+ * Shows a searchable grid of available instrument plugins.
+ */
+
+interface InstrumentDrawerProps {
+    /** Available instrument plugins from engine scan */
+    instruments: InstrumentDescriptor[];
+    /** Currently loaded instrument plugin ID (null = default Surge XT) */
+    currentPluginId: string | null;
+    /** Whether the scan is still in progress */
+    isLoading: boolean;
+    /** Called when user selects an instrument */
+    onSelect: (pluginId: string) => void;
+    /** Called when user clicks refresh to re-scan plugins */
+    onRefresh: () => void;
+}
+declare function InstrumentDrawer({ instruments, currentPluginId, isLoading, onSelect, onRefresh, }: InstrumentDrawerProps): React.ReactElement;
+
+/**
+ * VolumeSlider Component
+ *
+ * Compact horizontal volume slider for track volume control.
+ * Uses native HTML range input with custom styling.
+ */
+
+interface VolumeSliderProps {
+    /** Volume value from 0 to 1 */
+    value: number;
+    /** Called when volume changes (debounced) */
+    onChange: (value: number) => void;
+    /** Disable the slider */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const VolumeSlider: React.FC<VolumeSliderProps>;
+
+/**
+ * PanSlider Component
+ *
+ * Compact horizontal pan slider for track stereo positioning.
+ * Range: -1 (left) to +1 (right), 0 = center.
+ * No text label - tooltip only.
+ */
+
+interface PanSliderProps {
+    /** Pan value from -1 (left) to 1 (right), 0 = center */
+    value: number;
+    /** Called when pan changes (debounced) */
+    onChange: (value: number) => void;
+    /** Disable the slider */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const PanSlider: React.FC<PanSliderProps>;
+
+/**
+ * FxToggleBar Component
+ *
+ * Per-track FX control panel with 6 rows (one per FX category).
+ * Each row: [Category toggle] [Preset 1-5 buttons] [Dry/Wet slider]
+ *
+ * Signal chain order: EQ -> Compressor -> Chorus -> Phaser -> Delay -> Reverb
+ */
+
+interface FxToggleBarProps {
+    trackId: string;
+    fxState: TrackFxDetailState;
+    onToggle: (trackId: string, category: FxCategory, enabled: boolean) => void;
+    onPresetChange: (trackId: string, category: FxCategory, presetIndex: number) => void;
+    onDryWetChange: (trackId: string, category: FxCategory, value: number) => void;
+    disabled?: boolean;
+}
+declare const FxToggleBar: React.FC<FxToggleBarProps>;
+
+/**
+ * SorceryProgressBar Component
+ *
+ * A progress bar for long, uncertain wait times (10-30s). Supports two modes:
+ *
+ * 1. **Time-based mode** (when `estimatedDurationMs` is provided):
+ *    Uses elapsed time and an ease-out curve to pace progress realistically.
+ *    Reaches ~90% at the estimated completion time, then asymptotically
+ *    approaches 95% if the operation runs long.
+ *
+ * 2. **Phase-based mode** (legacy fallback, no `estimatedDurationMs`):
+ *    "Zeno's Paradox" style - progress moves quickly at first, then
+ *    asymptotically slows toward 95%.
+ *
+ * Visual style: Segmented "retro CLI" look with glowing teal accent,
+ * diagonal stripes, and subtle pulse animation.
+ */
+
+/**
+ * Props for SorceryProgressBar component
+ */
+interface SorceryProgressBarProps {
+    /** Whether loading is in progress */
+    isLoading: boolean;
+    /** Text shown during loading (default: "CONJURING...") */
+    statusText?: string;
+    /** Text shown on completion (default: "COMPLETE") */
+    completeText?: string;
+    /** Callback when loading completes */
+    onComplete?: () => void;
+    /** Height class override (default: "h-10") */
+    heightClass?: string;
+    /** Initial progress value (0-100) to resume from - persists across scene switches */
+    initialProgress?: number;
+    /** Callback when progress changes - use to persist progress in parent state */
+    onProgressChange?: (progress: number) => void;
+    /** Estimated total duration in ms - enables time-aware pacing */
+    estimatedDurationMs?: number;
+}
+/**
+ * Calculates target progress based on elapsed time and estimated duration.
+ * Uses an ease-out power curve for natural-feeling progress:
+ * - At 10% of estimated time: ~21%  (feels responsive early)
+ * - At 30% of estimated time: ~53%  (good midpoint feel)
+ * - At 50% of estimated time: ~74%  (past halfway visually)
+ * - At 80% of estimated time: ~88%  (approaching completion)
+ * - At 100% of estimated time: 90%  (leaves room for overshoot)
+ * - Beyond estimate: asymptotically approaches 95%
+ */
+declare function calculateTimeBasedTarget(elapsedMs: number, estimatedDurationMs: number): number;
+/**
+ * SorceryProgressBar - A mystical progress bar for uncertain wait times
+ */
+declare function SorceryProgressBar({ isLoading, statusText, completeText, onComplete, heightClass, initialProgress, onProgressChange, estimatedDurationMs, }: SorceryProgressBarProps): React.ReactElement | null;
+
+/**
+ * useSceneState — Scene-keyed state hook for plugin developers.
+ *
+ * Works like `useState`, but maintains separate state per scene.
+ * When the user switches scenes, the previous scene's state is preserved
+ * and restored when they switch back.
+ *
+ * Returns `[value, setForCurrentScene, setForScene]`:
+ * - `value` — state for the currently active scene
+ * - `setForCurrentScene(v)` — updates state for whatever scene is active at call time
+ * - `setForScene(sceneId, v)` — updates state for a specific scene (for async callbacks)
+ *
+ * Both setters support the functional updater pattern: `prev => next`.
+ *
+ * **Important:** For object/array `initialValue`, hoist to a module-level constant
+ * to keep the setter callbacks referentially stable:
+ * ```ts
+ * const EMPTY: string[] = [];
+ * const [items, setItems, setItemsForScene] = useSceneState(activeSceneId, EMPTY);
+ * ```
+ */
+type SetSceneState<T> = (value: T | ((prev: T) => T)) => void;
+type SetSceneStateForScene<T> = (sceneId: string, value: T | ((prev: T) => T)) => void;
+declare function useSceneState<T>(activeSceneId: string | null, initialValue: T): [T, SetSceneState<T>, SetSceneStateForScene<T>];
+
+/**
+ * Valid instrument roles for synth track generation.
+ * Used in LLM prompts and preset selection.
+ * Canonical source — imported by both plugin SDK and core services.
+ */
+declare const VALID_INSTRUMENT_ROLES: readonly string[];
+
+/**
+ * Plugin SDK Version
+ *
+ * Semver version of the plugin SDK contract.
+ * Plugins declare minSdkVersion in their manifest.
+ * Registry checks semver.gte(PLUGIN_SDK_VERSION, manifest.minHostVersion)
+ * during activation and marks incompatible plugins accordingly.
+ */
+declare const PLUGIN_SDK_VERSION = "1.0.0";
+
+/**
+ * FX Preset Definitions
+ *
+ * 5 presets per FX category (30 total).
+ *
+ * Parameter names must match the Tracktion Engine's AutomatableParameter names
+ * for each built-in plugin exactly (case-sensitive).
+ *
+ * Chorus & Phaser have ZERO automatable parameters — all values are set via
+ * XML state (CachedValues on the plugin ValueTree).
+ *
+ * Lives in shared/ so both main process (services) and renderer (UI) can import.
+ */
+
+/** All preset configs keyed by FX category */
+declare const FX_PRESET_CONFIGS: Record<FxCategory, FxPresetConfig>;
+
+/**
+ * Volume Conversion Utilities
+ *
+ * Converts between UI slider position (0-1) and engine dB values using a power
+ * curve with +6 dB headroom. The curve places unity gain (0 dB) at slider 0.75,
+ * giving the top 25% of the slider a meaningful 6 dB boost range instead of the
+ * previous perceptual dead zone.
+ *
+ * Mapping:
+ *   slider 0.00 → -60 dB (silence)
+ *   slider 0.75 →   0 dB (unity gain)
+ *   slider 1.00 →  +6 dB (max boost)
+ */
+/** Slider position that maps to 0 dB (unity gain) */
+declare const SLIDER_UNITY = 0.75;
+/** Maximum dB value at slider = 1.0 */
+declare const DB_MAX = 6;
+/** Minimum dB value (silence floor) */
+declare const DB_MIN = -60;
+/**
+ * Convert a UI slider position (0-1) to engine dB.
+ *
+ * @param slider - Slider value in [0, 1]
+ * @returns dB value in [DB_MIN, DB_MAX]
+ */
+declare function sliderToDb(slider: number): number;
+/**
+ * Convert an engine dB value back to a UI slider position (0-1).
+ * Inverse of sliderToDb().
+ *
+ * @param db - Volume in dB
+ * @returns Slider value in [0, 1]
+ */
+declare function dbToSlider(db: number): number;
+
+export { type BulkAddPlaceholderTrack, type ComposeProgressEvent, type ComposeProgressListener, type ComposeSceneOptions, type ComposeSceneResult, type CreateTrackOptions, DB_MAX, DB_MIN, DEFAULT_FX_CATEGORY_DETAIL, DEFAULT_FX_DRY_WET, type DeckBoundaryEvent, type DeckBoundaryListener, EMPTY_FX_DETAIL_STATE, EMPTY_FX_STATE, type ExportedPluginData, FX_CATEGORIES, FX_CHAIN_ORDER, FX_DISPLAY_LABELS, FX_ENGINE_PLUGIN_NAMES, FX_PRESET_CONFIGS, type FxCategory, type FxCategoryDetailState, type FxPreset, type FxPresetConfig, type FxPresetData, type FxPresetDataEntry, FxToggleBar, type FxToggleBarProps, type GeneratorPlugin, type GeneratorType, type InstrumentDescriptor, InstrumentDrawer, type InstrumentDrawerProps, type LLMGenerationRequest, type LLMGenerationResult, type MidiClipData, type MidiWriteResult, type MixInterpolation, type MusicalContext, PLUGIN_SDK_VERSION, PanSlider, type PluginAudioTextureRequest, type PluginAudioTextureResult, type PluginCapabilities, type PluginChordSegment, type PluginChordTiming, type PluginConcurrentTrackInfo, type PluginDownloadOptions, PluginError, type PluginErrorCode, type PluginFileDialogOptions, type PluginFxCategoryDetailState, type PluginGenerationContext, type PluginHost, type PluginHttpRequestOptions, type PluginHttpResponse, type PluginManifest, type PluginMidiNote, type PluginPresetData, type PluginPresetInfo, type PluginRegistration, type PluginSampleFilter, type PluginSampleImportResult, type PluginSampleInfo, type PluginSampleTrackInfo, type PluginSceneContext, type PluginSceneInfo, type PluginSettingsSchema, type PluginSettingsStore, type PluginStatus, type PluginSynthInfo, type PluginTrackFxDetailState, type PluginTrackHandle, type PluginTrackInfo, type PluginTrackRuntimeState, type PluginTransportState, type PluginUIProps, type PostProcessOptions, type SDKTrackRowProps, SLIDER_UNITY, type SavePluginPresetOptions, type SceneChangeListener, type SettingDefinition, type ShufflePresetResult, SorceryProgressBar, type TrackFxDetailState, type TrackFxState, TrackRow, type TrackStateChangeListener, type TransportEvent, type TransportEventListener, type UnsubscribeFn, VALID_INSTRUMENT_ROLES, VolumeSlider, calculateTimeBasedTarget, dbToSlider, sliderToDb, useSceneState };