@ericdisero/aurora-shared 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+# @ericdisero/aurora-shared
+
+Shared operations layer for the Aurora MCP server and CLI — the single tool surface (`ALL_OPERATIONS`), Aurora storage access (SQLite + project folders), Suno/MVSEP provider clients, the background-job model, split orchestration, and stack export.
+
+Most users want **`@ericdisero/aurora-mcp-server`** (MCP) or **`@ericdisero/aurora-cli`** (`aurora` binary) instead — both depend on this package.
+
+Full docs: [github.com/EricDisero/aurora-mcp](https://github.com/EricDisero/aurora-mcp).
+
+MIT. Copyright Blueprint Online Learning Inc.

package/dist/audio/ffmpeg.d.ts

@@ -0,0 +1,21 @@
+export declare function getFfmpegPath(): string;
+export declare function runFfmpeg(args: string[]): Promise<void>;
+/** Probe input duration in seconds via ffmpeg's `-i` banner (the installer
+ *  ships no ffprobe). Returns null when no Duration line appears. */
+export declare function probeDurationSeconds(inputPath: string): Promise<number | null>;
+/** Standardize an arbitrary input to 44.1kHz stereo 32-bit float WAV — the
+ *  single preprocessed format fed to MVSEP jobs and the `ee` phase-cancel
+ *  reference (aurora's standardizeToWav, verbatim args). */
+export declare function standardizeToWav(inputPath: string, outputPath: string): Promise<void>;
+/** Whether the bundled ffmpeg build includes the rubberband filter. */
+export declare function hasRubberband(): Promise<boolean>;
+/** Split a tempo factor into a chain of atempo filters (each must be in [0.5, 2]). */
+export declare function atempoChain(factor: number): string;
+export type PitchEngine = 'varispeed' | 'rubberband' | 'asetrate+atempo';
+export type AudioFormat = 'wav' | 'mp3';
+/** Pitch-shift by `semitones` (+/-). Output locked to 44.1kHz.
+ *  Default: varispeed (tempo shifts with pitch). preserveTempo: rubberband
+ *  when available, else asetrate + atempo correction. */
+export declare function pitchShift(inputPath: string, outputPath: string, semitones: number, preserveTempo: boolean, format: AudioFormat): Promise<PitchEngine>;
+/** Convert to mp3 (320k CBR), keeping source sample rate / channel layout. */
+export declare function convertToMp3(inputPath: string, outputPath: string): Promise<void>;

package/dist/audio/ffmpeg.js

@@ -0,0 +1,112 @@
+// ffmpeg operations — port of aurora tools/bridge/lib/ffmpeg-ops.ts +
+// src/main/audio/ffmpeg.ts. Binary ships with this package via
+// @ffmpeg-installer/ffmpeg (no Electron asar involved here).
+import { spawn } from 'node:child_process';
+import ffmpegInstaller from '@ffmpeg-installer/ffmpeg';
+const SAMPLE_RATE = 44100;
+export function getFfmpegPath() {
+    return ffmpegInstaller.path;
+}
+export function runFfmpeg(args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(getFfmpegPath(), args, { windowsHide: true });
+        let stderr = '';
+        proc.stderr.on('data', (d) => {
+            stderr += d.toString();
+        });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`ffmpeg exited ${code}: ${stderr.slice(-2000)}`));
+        });
+    });
+}
+/** Probe input duration in seconds via ffmpeg's `-i` banner (the installer
+ *  ships no ffprobe). Returns null when no Duration line appears. */
+export function probeDurationSeconds(inputPath) {
+    return new Promise((resolve) => {
+        const proc = spawn(getFfmpegPath(), ['-hide_banner', '-i', inputPath], { windowsHide: true });
+        let stderr = '';
+        proc.stderr.on('data', (d) => {
+            stderr += d.toString();
+        });
+        proc.on('error', () => resolve(null));
+        proc.on('close', () => {
+            const m = /Duration:\s*(\d+):(\d{2}):(\d{2}(?:\.\d+)?)/.exec(stderr);
+            if (!m)
+                return resolve(null);
+            resolve(Number(m[1]) * 3600 + Number(m[2]) * 60 + Number(m[3]));
+        });
+    });
+}
+/** Standardize an arbitrary input to 44.1kHz stereo 32-bit float WAV — the
+ *  single preprocessed format fed to MVSEP jobs and the `ee` phase-cancel
+ *  reference (aurora's standardizeToWav, verbatim args). */
+export async function standardizeToWav(inputPath, outputPath) {
+    await runFfmpeg(['-y', '-i', inputPath, '-ac', '2', '-ar', '44100', '-c:a', 'pcm_f32le', outputPath]);
+}
+let rubberbandCache = null;
+/** Whether the bundled ffmpeg build includes the rubberband filter. */
+export async function hasRubberband() {
+    if (rubberbandCache !== null)
+        return rubberbandCache;
+    rubberbandCache = await new Promise((resolve) => {
+        const proc = spawn(getFfmpegPath(), ['-hide_banner', '-filters'], { windowsHide: true });
+        let out = '';
+        proc.stdout.on('data', (d) => {
+            out += d.toString();
+        });
+        proc.on('error', () => resolve(false));
+        proc.on('close', () => resolve(/\brubberband\b/.test(out)));
+    });
+    return rubberbandCache;
+}
+/** Split a tempo factor into a chain of atempo filters (each must be in [0.5, 2]). */
+export function atempoChain(factor) {
+    const parts = [];
+    let f = factor;
+    while (f > 2.0) {
+        parts.push(2.0);
+        f /= 2.0;
+    }
+    while (f < 0.5) {
+        parts.push(0.5);
+        f /= 0.5;
+    }
+    parts.push(f);
+    return parts.map((p) => `atempo=${p.toFixed(6)}`).join(',');
+}
+function codecArgs(format) {
+    // wav mirrors the standardize format (44.1k float32); mp3 = 320k CBR.
+    return format === 'wav' ? ['-c:a', 'pcm_f32le'] : ['-c:a', 'libmp3lame', '-b:a', '320k'];
+}
+/** Pitch-shift by `semitones` (+/-). Output locked to 44.1kHz.
+ *  Default: varispeed (tempo shifts with pitch). preserveTempo: rubberband
+ *  when available, else asetrate + atempo correction. */
+export async function pitchShift(inputPath, outputPath, semitones, preserveTempo, format) {
+    const ratio = 2 ** (semitones / 12);
+    const shiftedRate = Math.round(SAMPLE_RATE * ratio);
+    let engine;
+    let filter;
+    if (!preserveTempo) {
+        engine = 'varispeed';
+        filter = `aresample=${SAMPLE_RATE},asetrate=${shiftedRate},aresample=${SAMPLE_RATE}`;
+    }
+    else if (await hasRubberband()) {
+        engine = 'rubberband';
+        filter = `aresample=${SAMPLE_RATE},rubberband=pitch=${ratio.toFixed(8)}`;
+    }
+    else {
+        engine = 'asetrate+atempo';
+        filter = `aresample=${SAMPLE_RATE},asetrate=${shiftedRate},aresample=${SAMPLE_RATE},${atempoChain(1 / ratio)}`;
+    }
+    await runFfmpeg(['-y', '-i', inputPath, '-filter:a', filter, ...codecArgs(format), outputPath]);
+    return engine;
+}
+/** Convert to mp3 (320k CBR), keeping source sample rate / channel layout. */
+export async function convertToMp3(inputPath, outputPath) {
+    await runFfmpeg(['-y', '-i', inputPath, ...codecArgs('mp3'), outputPath]);
+}
+//# sourceMappingURL=ffmpeg.js.map

package/dist/audio/wav.d.ts

@@ -0,0 +1,15 @@
+export interface DecodedWav {
+    sampleRate: number;
+    /** Planar: one Float32Array per channel, each `frames` long. */
+    channels: Float32Array[];
+    frames: number;
+}
+export declare function decodeWavFile(path: string): Promise<DecodedWav>;
+export declare function decodeWav(buf: Buffer): DecodedWav;
+/** Encode planar Float32 channels to a 32-bit float WAV buffer. No clipping. */
+export declare function encodeWavFloat32(channels: Float32Array[], sampleRate: number): Buffer;
+export declare function encodeWavFloat32File(path: string, channels: Float32Array[], sampleRate: number): Promise<void>;
+/** Element-wise A − (B + C + …). All inputs must share frame count + channel
+ *  count (true by construction — same source, length-preserving models). Output
+ *  keeps float headroom; no clipping/normalize. */
+export declare function subtractWavs(minuend: DecodedWav, ...subtrahends: DecodedWav[]): DecodedWav;

package/dist/audio/wav.js

@@ -0,0 +1,159 @@
+// Minimal RIFF/WAVE reader + writer. No dependency — we only need enough to
+// decode the WAVs MVSEP returns (PCM 16/24/32-bit int and 32-bit float) into
+// planar Float32 channels, do sample-by-sample phase-cancellation, and re-encode
+// 32-bit float WAV. Output may exceed ±1.0 — we keep full float headroom and do
+// NOT clip or normalize (per mvsep-separation-contract.md Part B).
+import { readFile, writeFile } from 'node:fs/promises';
+const WAVE_FORMAT_PCM = 0x0001;
+const WAVE_FORMAT_IEEE_FLOAT = 0x0003;
+const WAVE_FORMAT_EXTENSIBLE = 0xfffe;
+export async function decodeWavFile(path) {
+    const buf = await readFile(path);
+    return decodeWav(buf);
+}
+export function decodeWav(buf) {
+    if (buf.length < 12 || buf.toString('ascii', 0, 4) !== 'RIFF' || buf.toString('ascii', 8, 12) !== 'WAVE') {
+        throw new Error('Not a RIFF/WAVE file');
+    }
+    let fmtFound = false;
+    let audioFormat = WAVE_FORMAT_PCM;
+    let numChannels = 0;
+    let sampleRate = 0;
+    let bitsPerSample = 0;
+    let dataOffset = -1;
+    let dataLength = 0;
+    // Walk chunks starting after the 12-byte RIFF header.
+    let pos = 12;
+    while (pos + 8 <= buf.length) {
+        const chunkId = buf.toString('ascii', pos, pos + 4);
+        const chunkSize = buf.readUInt32LE(pos + 4);
+        const bodyStart = pos + 8;
+        if (chunkId === 'fmt ') {
+            audioFormat = buf.readUInt16LE(bodyStart);
+            numChannels = buf.readUInt16LE(bodyStart + 2);
+            sampleRate = buf.readUInt32LE(bodyStart + 4);
+            bitsPerSample = buf.readUInt16LE(bodyStart + 14);
+            // WAVE_FORMAT_EXTENSIBLE carries the real format in the subformat GUID's
+            // first 2 bytes (cbSize at +16, then valid bits/channel mask, then GUID).
+            if (audioFormat === WAVE_FORMAT_EXTENSIBLE && chunkSize >= 26) {
+                audioFormat = buf.readUInt16LE(bodyStart + 24);
+            }
+            fmtFound = true;
+        }
+        else if (chunkId === 'data') {
+            dataOffset = bodyStart;
+            // Clamp to the actual buffer (some encoders write a bogus 0xFFFFFFFF size).
+            dataLength = Math.min(chunkSize, buf.length - bodyStart);
+        }
+        // Chunks are word-aligned: an odd size is followed by a pad byte.
+        pos = bodyStart + chunkSize + (chunkSize % 2);
+    }
+    if (!fmtFound)
+        throw new Error('WAV missing fmt chunk');
+    if (dataOffset < 0)
+        throw new Error('WAV missing data chunk');
+    if (numChannels < 1)
+        throw new Error('WAV has no channels');
+    const bytesPerSample = bitsPerSample / 8;
+    const frameSize = bytesPerSample * numChannels;
+    const frames = Math.floor(dataLength / frameSize);
+    const channels = Array.from({ length: numChannels }, () => new Float32Array(frames));
+    const readSample = makeSampleReader(buf, audioFormat, bitsPerSample);
+    for (let f = 0; f < frames; f++) {
+        const frameBase = dataOffset + f * frameSize;
+        for (let ch = 0; ch < numChannels; ch++) {
+            channels[ch][f] = readSample(frameBase + ch * bytesPerSample);
+        }
+    }
+    return { sampleRate, channels, frames };
+}
+function makeSampleReader(buf, audioFormat, bitsPerSample) {
+    if (audioFormat === WAVE_FORMAT_IEEE_FLOAT) {
+        if (bitsPerSample === 32)
+            return (o) => buf.readFloatLE(o);
+        if (bitsPerSample === 64)
+            return (o) => buf.readDoubleLE(o);
+        throw new Error(`Unsupported float bit depth: ${bitsPerSample}`);
+    }
+    if (audioFormat === WAVE_FORMAT_PCM) {
+        if (bitsPerSample === 16)
+            return (o) => buf.readInt16LE(o) / 32768;
+        if (bitsPerSample === 24) {
+            return (o) => {
+                // 24-bit signed little-endian → sign-extend the high byte.
+                const v = buf[o] | (buf[o + 1] << 8) | (buf[o + 2] << 16);
+                const signed = v & 0x800000 ? v - 0x1000000 : v;
+                return signed / 8388608;
+            };
+        }
+        if (bitsPerSample === 32)
+            return (o) => buf.readInt32LE(o) / 2147483648;
+        if (bitsPerSample === 8)
+            return (o) => (buf.readUInt8(o) - 128) / 128;
+        throw new Error(`Unsupported PCM bit depth: ${bitsPerSample}`);
+    }
+    throw new Error(`Unsupported WAV audio format: 0x${audioFormat.toString(16)}`);
+}
+/** Encode planar Float32 channels to a 32-bit float WAV buffer. No clipping. */
+export function encodeWavFloat32(channels, sampleRate) {
+    const numChannels = channels.length;
+    if (numChannels === 0)
+        throw new Error('encodeWavFloat32: no channels');
+    const frames = channels[0].length;
+    const bytesPerSample = 4;
+    const blockAlign = numChannels * bytesPerSample;
+    const dataLength = frames * blockAlign;
+    const buf = Buffer.alloc(44 + dataLength);
+    buf.write('RIFF', 0, 'ascii');
+    buf.writeUInt32LE(36 + dataLength, 4);
+    buf.write('WAVE', 8, 'ascii');
+    buf.write('fmt ', 12, 'ascii');
+    buf.writeUInt32LE(16, 16); // PCM-style fmt chunk size
+    buf.writeUInt16LE(WAVE_FORMAT_IEEE_FLOAT, 20);
+    buf.writeUInt16LE(numChannels, 22);
+    buf.writeUInt32LE(sampleRate, 24);
+    buf.writeUInt32LE(sampleRate * blockAlign, 28); // byte rate
+    buf.writeUInt16LE(blockAlign, 32);
+    buf.writeUInt16LE(32, 34); // bits per sample
+    buf.write('data', 36, 'ascii');
+    buf.writeUInt32LE(dataLength, 40);
+    let offset = 44;
+    for (let f = 0; f < frames; f++) {
+        for (let ch = 0; ch < numChannels; ch++) {
+            buf.writeFloatLE(channels[ch][f], offset);
+            offset += bytesPerSample;
+        }
+    }
+    return buf;
+}
+export async function encodeWavFloat32File(path, channels, sampleRate) {
+    await writeFile(path, encodeWavFloat32(channels, sampleRate));
+}
+/** Element-wise A − (B + C + …). All inputs must share frame count + channel
+ *  count (true by construction — same source, length-preserving models). Output
+ *  keeps float headroom; no clipping/normalize. */
+export function subtractWavs(minuend, ...subtrahends) {
+    const numChannels = minuend.channels.length;
+    const frames = minuend.frames;
+    for (const s of subtrahends) {
+        if (s.channels.length !== numChannels) {
+            throw new Error(`Channel-count mismatch in phase cancellation: ${s.channels.length} vs ${numChannels}`);
+        }
+        if (s.frames !== frames) {
+            throw new Error(`Frame-count mismatch in phase cancellation: ${s.frames} vs ${frames}`);
+        }
+    }
+    const out = Array.from({ length: numChannels }, (_, ch) => {
+        const result = new Float32Array(frames);
+        const base = minuend.channels[ch];
+        for (let i = 0; i < frames; i++) {
+            let v = base[i];
+            for (const s of subtrahends)
+                v -= s.channels[ch][i];
+            result[i] = v;
+        }
+        return result;
+    });
+    return { sampleRate: minuend.sampleRate, channels: out, frames };
+}
+//# sourceMappingURL=wav.js.map

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export interface AuroraKeyConfig {
+    sunoApiKey?: string;
+    kieApiKey?: string;
+    mvsepApiKey?: string;
+    sunoApiBaseUrl?: string;
+}
+export declare function getConfigPath(): string;
+export declare function readKeyConfig(): AuroraKeyConfig;
+export declare function writeKeyConfig(partial: AuroraKeyConfig): AuroraKeyConfig;
+export declare function getSunoKey(): string | undefined;
+export declare function getKieKey(): string | undefined;
+export declare function getSunoBaseUrlOverride(): string | undefined;
+export declare function getMvsepKey(): string | undefined;
+export declare function requireMvsepKey(): string;

package/dist/config.js

@@ -0,0 +1,50 @@
+// Provider API-key resolution. Priority: environment variables (works with the
+// MCP config `env` block and CI) → ~/.aurora/config.json (written by
+// `aurora keys set`). Auth to Aurora itself: NONE — the app runs fully open
+// (AUTH_ENABLED=false; slates-api device-code auth arrives with D4, out of
+// scope here). These keys are the PROVIDER dev keys (dev-direct mode).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function getConfigPath() {
+    return join(homedir(), '.aurora', 'config.json');
+}
+export function readKeyConfig() {
+    const path = getConfigPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeKeyConfig(partial) {
+    const merged = { ...readKeyConfig(), ...partial };
+    const dir = join(homedir(), '.aurora');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(getConfigPath(), JSON.stringify(merged, null, 2));
+    return merged;
+}
+export function getSunoKey() {
+    return process.env.SUNO_API_KEY || readKeyConfig().sunoApiKey;
+}
+export function getKieKey() {
+    return process.env.KIE_API_KEY || readKeyConfig().kieApiKey;
+}
+export function getSunoBaseUrlOverride() {
+    return process.env.SUNO_API_BASE_URL || readKeyConfig().sunoApiBaseUrl;
+}
+export function getMvsepKey() {
+    return process.env.MVSEP_API_KEY || readKeyConfig().mvsepApiKey;
+}
+export function requireMvsepKey() {
+    const key = getMvsepKey();
+    if (!key) {
+        throw new Error('MVSEP_API_KEY is not configured. Set the MVSEP_API_KEY environment variable ' +
+            '(e.g. in your MCP config "env" block) or run: aurora keys set --mvsep-api-key <key>');
+    }
+    return key;
+}
+//# sourceMappingURL=config.js.map

package/dist/db.d.ts

@@ -0,0 +1,3 @@
+import Database from 'better-sqlite3';
+export declare function getDb(): Database.Database;
+export declare function closeDb(): void;

package/dist/db.js

@@ -0,0 +1,121 @@
+// Aurora DB access without Electron — same better-sqlite3, same WAL pragmas,
+// same migrations as aurora/src/main/database/. The MCP and the running app
+// can coexist on this DB: WAL allows concurrent readers, busy_timeout waits
+// out transient writer locks.
+//
+// SCHEMA LOCKSTEP RULE: this file mirrors aurora/src/main/database/migrations.ts
+// at schema version 1. If the app migrates past v1, openDb() refuses to write
+// with an "update your aurora-mcp packages" error instead of corrupting newer
+// schema assumptions.
+import Database from 'better-sqlite3';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { getDbPath, getUserDataDir } from './paths.js';
+const KNOWN_SCHEMA_VERSION = 1;
+let db = null;
+export function getDb() {
+    if (db)
+        return db;
+    mkdirSync(getUserDataDir(), { recursive: true });
+    db = new Database(getDbPath());
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    db.pragma('busy_timeout = 5000');
+    const version = db.pragma('user_version', { simple: true });
+    if (version > KNOWN_SCHEMA_VERSION) {
+        const path = getDbPath();
+        db.close();
+        db = null;
+        throw new Error(`Aurora database at ${path} is schema v${version}, newer than this tool understands (v${KNOWN_SCHEMA_VERSION}). ` +
+            'Update the @ericdisero/aurora-* packages (npm i -g @ericdisero/aurora-cli@latest, or clear the npx cache).');
+    }
+    runMigrations(db);
+    return db;
+}
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
+// Verbatim port of aurora/src/main/database/migrations.ts (schema v1).
+function runMigrations(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id          TEXT PRIMARY KEY,
+      name        TEXT NOT NULL,
+      source      TEXT NOT NULL CHECK(source IN ('generated', 'imported')),
+      audio_path  TEXT NOT NULL,
+      gen_meta    TEXT,
+      created_at  INTEGER NOT NULL,
+      updated_at  INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS project_stems (
+      id          TEXT PRIMARY KEY,
+      project_id  TEXT NOT NULL,
+      stem_type   TEXT NOT NULL CHECK(stem_type IN ('vocals','kick','snare','toms','hats','bass','ee')),
+      path        TEXT NOT NULL,
+      origin      TEXT NOT NULL CHECK(origin IN ('mvsep','synthesized')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS reference_tracks (
+      id                 TEXT PRIMARY KEY,
+      name               TEXT NOT NULL,
+      audio_path         TEXT NOT NULL,
+      cached_curve_path  TEXT,
+      curve_status       TEXT NOT NULL DEFAULT 'none'
+                         CHECK(curve_status IN ('none','analyzing','cached','error')),
+      created_at         INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_project_stems_project ON project_stems(project_id);
+    CREATE INDEX IF NOT EXISTS idx_projects_updated ON projects(updated_at DESC);
+  `);
+    const version = database.pragma('user_version', { simple: true });
+    if (version < 1) {
+        database.transaction(() => {
+            database.exec(`
+        ALTER TABLE projects ADD COLUMN dir_name TEXT;
+
+        CREATE TABLE IF NOT EXISTS project_assets (
+          id               TEXT PRIMARY KEY,
+          project_id       TEXT NOT NULL,
+          kind             TEXT NOT NULL CHECK(kind IN ('generation','cover','import','reference','master')),
+          name             TEXT NOT NULL,
+          path             TEXT NOT NULL,
+          origin           TEXT,
+          source_asset_id  TEXT,
+          ref_id           TEXT,
+          created_at       INTEGER NOT NULL,
+          FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_project_assets_project ON project_assets(project_id);
+
+        ALTER TABLE project_stems ADD COLUMN asset_id TEXT;
+        DROP INDEX IF EXISTS idx_project_stems_unique;
+        CREATE INDEX IF NOT EXISTS idx_project_stems_asset ON project_stems(asset_id);
+      `);
+            const projects = database
+                .prepare('SELECT id, name, source, audio_path, gen_meta, created_at FROM projects')
+                .all();
+            const setDir = database.prepare('UPDATE projects SET dir_name = ? WHERE id = ?');
+            const insertAsset = database.prepare(`INSERT INTO project_assets (id, project_id, kind, name, path, origin, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`);
+            const linkStems = database.prepare('UPDATE project_stems SET asset_id = ? WHERE project_id = ?');
+            for (const p of projects) {
+                setDir.run(p.id, p.id);
+                if (p.audio_path) {
+                    const assetId = randomUUID();
+                    const kind = p.source === 'generated' ? 'generation' : 'import';
+                    insertAsset.run(assetId, p.id, kind, p.name, p.audio_path, p.gen_meta, p.created_at);
+                    linkStems.run(assetId, p.id);
+                }
+            }
+            database.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_project_stems_asset_unique ON project_stems(asset_id, stem_type);');
+            database.pragma('user_version = 1');
+        })();
+    }
+}
+//# sourceMappingURL=db.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { ALL_OPERATIONS, type Operation, type OperationResult } from './operations/index.js';
+export { SKILLS } from './skills/content.js';
+export { getUserDataDir, getDbPath, getProjectsDirectory, getSettings } from './paths.js';
+export { readKeyConfig, writeKeyConfig, getConfigPath, getSunoKey, getKieKey, getMvsepKey } from './config.js';
+export { getDb, closeDb } from './db.js';
+export { listJobs, loadJob } from './jobs.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { ALL_OPERATIONS } from './operations/index.js';
+export { SKILLS } from './skills/content.js';
+export { getUserDataDir, getDbPath, getProjectsDirectory, getSettings } from './paths.js';
+export { readKeyConfig, writeKeyConfig, getConfigPath, getSunoKey, getKieKey, getMvsepKey } from './config.js';
+export { getDb, closeDb } from './db.js';
+export { listJobs, loadJob } from './jobs.js';
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/jobs.d.ts

@@ -0,0 +1,45 @@
+import { type SplitJobName } from './split.js';
+export type JobKind = 'generate' | 'sounds' | 'cover' | 'split';
+export interface JobManifest {
+    jobId: string;
+    kind: JobKind;
+    status: 'running' | 'done' | 'error';
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+    projectId: string;
+    /** Display-name base for landed assets. */
+    baseName: string;
+    /** Original op params, for traceability. */
+    params: Record<string, unknown>;
+    provider: {
+        /** generate / sounds / cover */
+        taskId?: string;
+        sourceAssetId?: string | null;
+        /** split */
+        assetId?: string;
+        stemsDir?: string;
+        hashes?: Record<SplitJobName, string>;
+    };
+    /** Per-sub-unit idempotency flags (split job names / 'assets'). */
+    landed: Record<string, boolean>;
+    /** DB ids of landed assets. */
+    assetIds: string[];
+    /** Landed stems (type + path). */
+    stems: Array<{
+        stemType: string;
+        path: string;
+    }>;
+    lastStatus?: string;
+    /** Listenable mid-generation preview URLs (expire server-side — never persist
+     *  as asset paths; they're a head start, not the product). */
+    streamUrls?: string[];
+    stage: string;
+}
+export declare function saveJob(m: JobManifest): Promise<void>;
+export declare function loadJob(jobId: string): Promise<JobManifest | null>;
+export declare function listJobs(): Promise<JobManifest[]>;
+export declare function newJobManifest(kind: JobKind, jobId: string, projectId: string, baseName: string, params: Record<string, unknown>, provider: JobManifest['provider']): JobManifest;
+/** Advance a running job by ONE provider poll, landing whatever is ready.
+ *  Idempotent and serialized per jobId — the status op can hit it repeatedly. */
+export declare function advanceJob(m: JobManifest): Promise<JobManifest>;