@ericdisero/aurora-shared 0.1.0

package/dist/sidecars.js

@@ -0,0 +1,109 @@
+// Python sidecar spawns (RVC vocal upscale + MIDI rip) — mirrors aurora's
+// resolve/spawn pattern (src/main/rvc/upscale.ts, src/main/midi/rip.ts) without
+// Electron. The sidecars live in the aurora repo (dev) or the installed app's
+// resources (packaged); neither ships in this npm package. Resolution order:
+//   1. AURORA_RVC_SIDECAR / AURORA_MIDI_SIDECAR — direct path to the exe
+//   2. AURORA_REPO/<sidecar>/dist/<exe>           (frozen dev build)
+//   3. AURORA_REPO/<sidecar>/main.py via python   (dev, deps installed)
+//   4. installed app resources (best-effort known install locations)
+// Missing → a clear, actionable error (the sidecars also need their Python
+// deps / PyInstaller freeze — see aurora/CLAUDE.md Status).
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+function resolveSidecar(kind) {
+    const dirName = kind === 'rvc' ? 'sidecar-rvc' : 'sidecar-midi';
+    const exeName = (kind === 'rvc' ? 'aurora-rvc' : 'aurora-midi') + (process.platform === 'win32' ? '.exe' : '');
+    const searched = [];
+    const direct = process.env[kind === 'rvc' ? 'AURORA_RVC_SIDECAR' : 'AURORA_MIDI_SIDECAR'];
+    if (direct) {
+        searched.push(direct);
+        if (existsSync(direct))
+            return { resolved: { command: direct, baseArgs: [] }, searched };
+    }
+    const repo = process.env.AURORA_REPO;
+    if (repo) {
+        const frozen = join(repo, dirName, 'dist', exeName);
+        searched.push(frozen);
+        if (existsSync(frozen))
+            return { resolved: { command: frozen, baseArgs: [] }, searched };
+        const mainPy = join(repo, dirName, 'main.py');
+        searched.push(mainPy);
+        if (existsSync(mainPy)) {
+            const python = process.platform === 'win32' ? 'python' : 'python3';
+            return { resolved: { command: python, baseArgs: [mainPy] }, searched };
+        }
+    }
+    // Installed-app resources (packaged layouts).
+    const installCandidates = process.platform === 'win32'
+        ? [join(homedir(), 'AppData', 'Local', 'Programs', 'Aurora', 'resources', dirName, exeName)]
+        : process.platform === 'darwin'
+            ? [join('/Applications', 'Aurora.app', 'Contents', 'Resources', dirName, exeName)]
+            : [];
+    for (const c of installCandidates) {
+        searched.push(c);
+        if (existsSync(c))
+            return { resolved: { command: c, baseArgs: [] }, searched };
+    }
+    return { resolved: null, searched };
+}
+function runSidecar(resolved, args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(resolved.command, [...resolved.baseArgs, ...args], { windowsHide: true });
+        let stderr = '';
+        proc.stderr.on('data', (d) => {
+            stderr += d.toString();
+        });
+        proc.stdout.on('data', () => {
+            // JSON-lines progress — consumed silently in the MCP (blocking call).
+        });
+        proc.on('error', reject);
+        proc.on('close', (code) => {
+            if (code === 0)
+                resolve({ stderrTail: stderr.slice(-2000) });
+            else
+                reject(new Error(`sidecar exited ${code}: ${stderr.slice(-2000)}`));
+        });
+    });
+}
+export async function runRvcUpscale(params) {
+    const { resolved, searched } = resolveSidecar('rvc');
+    if (!resolved) {
+        throw new Error('RVC sidecar not found. Set AURORA_REPO to your aurora checkout (or AURORA_RVC_SIDECAR to the ' +
+            `frozen exe). Searched: ${searched.join(' | ') || '(no hints set)'}. ` +
+            'Note: the sidecar needs its Python deps installed (see aurora/sidecar-rvc/).');
+    }
+    if (!existsSync(params.inputPath))
+        throw new Error(`Input not found: ${params.inputPath}`);
+    await mkdir(dirname(params.outputPath), { recursive: true });
+    const args = ['--in', params.inputPath, '--out', params.outputPath, '--model', params.model || 'jb'];
+    if (typeof params.f0UpKey === 'number')
+        args.push('--f0-up-key', String(params.f0UpKey));
+    await runSidecar(resolved, args);
+    if (!existsSync(params.outputPath)) {
+        throw new Error(`RVC sidecar finished but produced no output at ${params.outputPath}`);
+    }
+    return params.outputPath;
+}
+export async function runRipMidi(params) {
+    const { resolved, searched } = resolveSidecar('midi');
+    if (!resolved) {
+        throw new Error('MIDI sidecar not found. Set AURORA_REPO to your aurora checkout (or AURORA_MIDI_SIDECAR to the ' +
+            `frozen exe). Searched: ${searched.join(' | ') || '(no hints set)'}. ` +
+            'Note: the sidecar needs its Python 3.9 deps installed (see aurora/sidecar-midi/).');
+    }
+    if (!existsSync(params.inputPath))
+        throw new Error(`Input not found: ${params.inputPath}`);
+    await mkdir(dirname(params.outputPath), { recursive: true });
+    const args = ['--in', params.inputPath, '--out', params.outputPath, '--mode', params.mode];
+    if (params.instrument)
+        args.push('--instrument', params.instrument);
+    await runSidecar(resolved, args);
+    if (!existsSync(params.outputPath)) {
+        throw new Error(`MIDI sidecar finished but produced no .mid at ${params.outputPath}`);
+    }
+    return params.outputPath;
+}
+//# sourceMappingURL=sidecars.js.map

package/dist/skills/content.d.ts

@@ -0,0 +1 @@
+export declare const SKILLS: Record<string, string>;

package/dist/skills/content.js

@@ -0,0 +1,9 @@
+// GENERATED — do not edit. Source: packages/shared/skills/*.md
+// Regenerated by scripts/embed-skills.mjs on every build.
+export const SKILLS = {
+    "aurora-cost-discipline": "---\nname: aurora-cost-discipline\ndescription: Credit and spend discipline for every paid Aurora operation (Suno generation/cover/sounds/WAV, MVSEP splits). Fires before any aurora_generate, aurora_cover, aurora_sounds, aurora_split, or aurora_fetch_wav call.\n---\n\n# Aurora Cost Discipline\n\nTwo metered providers sit behind Aurora's cloud ops. Spend is real money. The rules:\n\n## Always\n\n1. **`aurora_get_credits` BEFORE the first paid call of a session** — and after a batch, to log actual spend.\n2. **Never re-split.** `aurora_split` burns real MVSEP credits; the op refuses when 7 stems already exist — don't work around it. Check `aurora_list_assets` first.\n3. **Batch authorization, not per-call nagging.** When the user approves a multi-generation plan (\"make me 4 braams and a riser\"), that approval covers the enumerated batch — don't re-confirm each call. NEW spend beyond the approved batch needs a fresh ask.\n\n## Known costs (sunoapi.org credits, measured 2026-06-10)\n\n| Op | Cost |\n|---|---|\n| `aurora_sounds` | ~2.5 credits (~$0.0125) — the cheap verification + layer tool |\n| `aurora_cover` | ~12 credits + ~0.4 per WAV fetch |\n| `aurora_fetch_wav` | ~0.4 credits per conversion |\n| `aurora_generate` | not yet measured — check credits before/after and report the delta |\n| `aurora_split` | MVSEP credits, priced by audio duration (separate balance) |\n| `aurora_get_credits`, all local ffmpeg/stack/project ops | FREE |\n\n## Cheap-first ladder\n\n- Verifying a pipeline or experimenting? `aurora_sounds` first (2.5 credits), full `aurora_generate` only when the user wants a track.\n- Audition MP3s before paying for WAV upgrades; `aurora_fetch_wav` only the keepers.\n- Local ops (`aurora_pitch_shift`, `aurora_convert`, stack everything) cost nothing — prefer them over regenerating.\n",
+    "aurora-music-production": "---\nname: aurora-music-production\ndescription: End-to-end Aurora workflow — create a project, generate or cover tracks, manufacture sounds, split into 7 stems, layer in the stack, export aligned WAVs for the DAW. Use when driving Aurora (the AI audio workbench) for any music production task.\n---\n\n# Aurora Music Production Workflow\n\nAurora is the desktop layer between AI music generation and a real DAW: generate AI music, split anything into stems, keep it all organized. Files on disk ARE the product — everything you create lands in a real project folder the user can open, play, and drag into their DAW.\n\n## Session start\n\n1. `aurora_get_workspace_state` — projects list, key status, folder locations. Once per session.\n2. `aurora_get_credits` — Suno credits + MVSEP minutes. ALWAYS before paid calls (see aurora-cost-discipline).\n\n## The verbs\n\n- **Generate** (`aurora_generate`) — full track from a prompt. 2 variations land as assets. 1-3 min.\n- **Cover** (`aurora_cover`) — style-transform an existing asset or file: same musical content, new style. `audioWeight` is the dial: 0 = new style dominates, 1 = stay close to the source.\n- **Sounds** (`aurora_sounds`) — samples, one-shots, loops with key/tempo lock. Fast (~20-30s), cheap (~2.5 credits). The layer-manufacturing tool: braams, booms, transitions, textures.\n- **Split** (`aurora_split`) — ANY asset → 7 stems (vocals, kick, snare, toms, hats, bass, everything-else). REAL MVSEP credits; never re-split (the op refuses if 7 stems exist).\n- **Stack** (`aurora_stack_*`) — layer assets/stems on lanes with offsets and gain, then `aurora_stack_export` for a sample-aligned multi-WAV bundle (drop at time zero in any DAW).\n\n## Long-op discipline\n\nGeneration and splits take minutes. Prefer `background: true` + `aurora_get_job_status` polling every 10-20s:\n\n- Status responses include `streamUrls` while a generation is still cooking — give the user the link, they can LISTEN ~30-45s in, minutes before files land.\n- Split stems land PROGRESSIVELY: vocals/kick/snare/toms/hats/bass appear as each MVSEP job finishes; everything-else (ee) lands last.\n- Jobs survive restarts — `aurora_list_jobs` recovers anything in flight.\n\n## Files + organization\n\n- Project folder: `generations/ covers/ imports/ references/ stems/<asset>/ masters/ stack-export/ stack.json`.\n- MP3 lands first; `aurora_fetch_wav` upgrades a generation/cover to provider WAV (~0.4 credits).\n- `aurora_pitch_shift` and `aurora_convert` are FREE local ffmpeg ops.\n- Mastering (analyze → mix → export) lives in the Aurora app window — point the user there once stems exist; it is not agent-drivable yet.\n\n## Suno prompting quick rules\n\n- Custom mode = set `style` AND `title` together; then `prompt` carries the LYRICS.\n- Non-custom mode: `prompt` is a track description.\n- `negativeTags` is ONE comma-separated string (\"Heavy Metal, Upbeat Drums\").\n- Sounds prompts: concrete and physical (\"huge cinematic braam, dark low brass, trailer hit\"), max 500 chars, lock `soundKey`/`tempo` when the track they'll sit in is known.\n",
+    "aurora-split-and-stems": "---\nname: aurora-split-and-stems\ndescription: How Aurora's 7-stem split works (3 MVSEP jobs + phase cancellation), what the stems are, progressive landing, cost rules, and where stems live on disk. Use when calling aurora_split or working with split stems.\n---\n\n# Aurora Split & Stems\n\n## The 7 stems\n\n`vocals, kick, snare, toms, hats, bass, ee` (everything-else). Only 5 come from MVSEP; **hats** and **ee** are synthesized locally by phase cancellation (hats = drums − kick − snare − toms; ee = original − vocals − drums − bass). This is why ee always lands LAST.\n\n## How a split runs\n\n3 parallel MVSEP jobs (vocals model, drum separation, bass model) on one standardized 44.1kHz float32 WAV. Stems land **progressively** as each job finishes:\n\n- vocals job → `vocals`\n- drums job → `kick`, `snare`, `toms`, `hats`\n- bass job → `bass`\n- all three done → `ee`\n\nWith `background: true`, `aurora_get_job_status` shows the per-job landing state — the user can start auditioning early stems while the rest cook. Typical total: 3-5 minutes (longer if the MVSEP queue is busy — free-tier keys run 1 concurrent job, so the 3 jobs may serialize).\n\n## Cost rules\n\n- REAL MVSEP credits, priced by audio duration. Check `aurora_get_credits` (mvsepPremiumMinutes) first.\n- **Never re-split**: the op returns existing stems instead of spending again when a full set exists.\n- Any asset kind splits: generations, covers, imports, AND references (split-a-reference is a first-class loop for studying an arrangement).\n\n## On disk\n\nStems live at `<project>/stems/<asset-slug>-<id6>/*.wav` — 32-bit float, sample-aligned by construction. They are DAW-ready files: stack them (`aurora_stack_add_lane` with `stemType`), pitch them (`aurora_pitch_shift`), rip MIDI from them (`aurora_rip_midi`), or point the user at the folder.\n\nMastering against a reference (analyze → mix → export) happens in the Aurora app window from any split set — not agent-drivable yet.\n",
+    "aurora-suno-prompting": "---\nname: aurora-suno-prompting\ndescription: Prompting guide for Aurora's Suno-backed generation ops — generate (full tracks), cover (style transforms, the audioWeight dial), and sounds (samples/one-shots/loops with key+tempo lock). Use when writing prompts for aurora_generate, aurora_cover, or aurora_sounds.\n---\n\n# Suno Prompting for Aurora\n\n## aurora_generate — full tracks\n\nTwo modes, switched by whether you set `style`/`title`:\n\n- **Description mode** (no style/title): `prompt` describes the track — genre, mood, instrumentation, tempo feel, structure. One coherent paragraph beats keyword soup.\n- **Custom mode** (`style` AND `title` set): `prompt` carries the LYRICS; `style` carries the genre/production language. The provider requires BOTH style and title together.\n\nControls: `instrumental: true` for no vocals; `vocalGender` male/female; `negativeTags` as ONE comma-separated string of styles to avoid (\"Heavy Metal, Upbeat Drums\").\n\n## aurora_cover — style transforms\n\nThe source's musical content (melody, structure) is kept; the style is replaced.\n\n- `audioWeight` is the single most important dial: **0 = the new style dominates, 1 = stay close to the source.** 0.5-0.7 is the useful middle for \"same song, new genre\".\n- Custom mode rules are the same: `style` + `title` together, prompt describes the transformation target.\n- Source cap: 8 minutes. Project asset (`sourceAssetId`) or external file (`sourcePath`).\n\n## aurora_sounds — samples, one-shots, loops\n\nThe layer-manufacturing tool. Prompts are short (max 500 chars), physical, and concrete:\n\n- Name the sound type: braam, boom, riser, downer, whoosh, impact, drone, texture, loop.\n- Describe the material: \"dark low brass\", \"metallic scrape\", \"sub-heavy 808\", \"airy granular pad\".\n- Context helps: \"trailer hit\", \"transition\", \"intro swell\".\n- Lock `soundKey` (e.g. \"Cm\", \"F#\") and `tempo` (BPM) when the destination track is known — this is the point of the tool.\n- `loop: true` for loopable textures/grooves.\n\nEach call returns 2 variations — audition both before generating more.\n",
+};
+//# sourceMappingURL=content.js.map

package/dist/split.d.ts

@@ -0,0 +1,24 @@
+import type { MvsepJobSpec, ProjectAsset, ProjectStem, SeparationResultFile } from './types.js';
+export type SplitJobName = 'vocals' | 'drumsep' | 'bass';
+export declare const JOB_SPECS: Record<SplitJobName, MvsepJobSpec>;
+export interface SplitPreparation {
+    asset: ProjectAsset;
+    stemsDir: string;
+    originalPath: string;
+    audioBytes: Buffer;
+}
+/** Step 0: resolve the asset + standardize its audio (the single preprocessed
+ *  file all 3 jobs AND the ee reference use). */
+export declare function prepareSplit(assetId: string): Promise<SplitPreparation>;
+/** Step 1: fire the 3 CREATE jobs with the contract's 2s stagger. Returns the
+ *  provider hashes (persist these — they survive process restarts). */
+export declare function createSplitJobs(audioBytes: Buffer): Promise<Record<SplitJobName, string>>;
+/** Land ONE finished job's stems (progressive). Returns the stem rows created.
+ *  Idempotent per job — re-running re-downloads and upserts in place. */
+export declare function landSplitJob(job: SplitJobName, files: SeparationResultFile[], asset: ProjectAsset, stemsDir: string): Promise<ProjectStem[]>;
+/** Final step once ALL THREE jobs have landed: synthesize ee
+ *  (original − vocals − drums-bus − bass), then drop the drums-bus intermediate. */
+export declare function finalizeSplit(asset: ProjectAsset, stemsDir: string): Promise<ProjectStem>;
+/** Blocking end-to-end split with progressive landing — each job's stems
+ *  register as that job finishes. Returns all 7 stem rows. */
+export declare function runSplitBlocking(assetId: string, onProgress?: (stage: string) => void): Promise<ProjectStem[]>;

package/dist/split.js

@@ -0,0 +1,162 @@
+// 3-job MVSEP split orchestration — port of aurora/src/main/split/orchestrate.ts
+// (real-call verified 2026-06-10), restructured for PER-STEM PROGRESSIVE
+// LANDING: each MVSEP job's stems register the moment that job finishes instead
+// of gating on all three. Dependency graph:
+//   vocals job (40)  → vocals
+//   drumsep job (37) → kick, snare, toms, + hats (= drums − kick − snare − toms)
+//   bass job (41)    → bass
+//   ee               → needs ALL THREE (original − vocals − drums − bass)
+// Contract: aurora/docs/build-specs/mvsep-separation-contract.md.
+import { join } from 'node:path';
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { awaitSeparationResult, createSeparationJob } from './providers/mvsep.js';
+import { getAsset, getAssetStemsDir } from './storage/assets.js';
+import { upsertStem } from './storage/stems.js';
+import { standardizeToWav } from './audio/ffmpeg.js';
+import { decodeWavFile, encodeWavFloat32File, subtractWavs } from './audio/wav.js';
+const CONCURRENT_DELAY_MS = 2000; // contract CONCURRENT_DELAY=2
+const OUTPUT_FORMAT_WAV32 = '4';
+const IS_DEMO = '0';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// The 3 CREATE jobs (contract Part A; re-verified vs live algorithms 2026-06-10).
+export const JOB_SPECS = {
+    // BS Roformer ver 2025.07 → vocals + instrumental.
+    vocals: { sep_type: '40', output_format: OUTPUT_FORMAT_WAV32, is_demo: IS_DEMO, add_opt1: '81' },
+    // DrumSep MelBand Roformer 6-stem. add_opt1=7 is MANDATORY.
+    drumsep: { sep_type: '37', output_format: OUTPUT_FORMAT_WAV32, is_demo: IS_DEMO, add_opt1: '7', add_opt2: '0' },
+    // MVSep Bass, BS Roformer SW + SCNet XL → bass + other.
+    bass: { sep_type: '41', output_format: OUTPUT_FORMAT_WAV32, is_demo: IS_DEMO, add_opt1: '5', add_opt2: '0' }
+};
+/** Find a file by lowercased-filename predicate, else throw a clear error. */
+function pickFile(files, match) {
+    const hit = files.find((f) => match(f.filename.toLowerCase()) || match(f.url.toLowerCase()));
+    if (!hit) {
+        throw new Error(`Could not locate expected stem in MVSEP result. Files: ${files.map((f) => f.filename).join(', ')}`);
+    }
+    return hit.url;
+}
+async function downloadTo(url, destPath) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Stem download failed (HTTP ${res.status}): ${url}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    await writeFile(destPath, buf);
+}
+/** Step 0: resolve the asset + standardize its audio (the single preprocessed
+ *  file all 3 jobs AND the ee reference use). */
+export async function prepareSplit(assetId) {
+    const asset = getAsset(assetId);
+    if (!asset)
+        throw new Error(`Asset not found: ${assetId}`);
+    if (!existsSync(asset.path)) {
+        throw new Error(`Asset audio file is missing on disk: ${asset.path}`);
+    }
+    const stemsDir = getAssetStemsDir(asset);
+    await mkdir(stemsDir, { recursive: true });
+    const originalPath = join(stemsDir, 'original.wav');
+    await standardizeToWav(asset.path, originalPath);
+    const audioBytes = await readFile(originalPath);
+    return { asset, stemsDir, originalPath, audioBytes };
+}
+/** Step 1: fire the 3 CREATE jobs with the contract's 2s stagger. Returns the
+ *  provider hashes (persist these — they survive process restarts). */
+export async function createSplitJobs(audioBytes) {
+    const vocals = await createSeparationJob(audioBytes, JOB_SPECS.vocals);
+    await sleep(CONCURRENT_DELAY_MS);
+    const drumsep = await createSeparationJob(audioBytes, JOB_SPECS.drumsep);
+    await sleep(CONCURRENT_DELAY_MS);
+    const bass = await createSeparationJob(audioBytes, JOB_SPECS.bass);
+    return { vocals: vocals.hash, drumsep: drumsep.hash, bass: bass.hash };
+}
+/** Land ONE finished job's stems (progressive). Returns the stem rows created.
+ *  Idempotent per job — re-running re-downloads and upserts in place. */
+export async function landSplitJob(job, files, asset, stemsDir) {
+    const { projectId } = asset;
+    const rows = [];
+    if (job === 'vocals') {
+        const url = pickFile(files, (n) => /vocal/.test(n) && !/no_vocal|instrumental/.test(n));
+        const dest = join(stemsDir, 'vocals.wav');
+        await downloadTo(url, dest);
+        rows.push(upsertStem({ projectId, assetId: asset.id, stemType: 'vocals', path: dest, origin: 'mvsep' }));
+        return rows;
+    }
+    if (job === 'bass') {
+        const url = pickFile(files, (n) => /bass/.test(n) && !/no_bass|other/.test(n));
+        const dest = join(stemsDir, 'bass.wav');
+        await downloadTo(url, dest);
+        rows.push(upsertStem({ projectId, assetId: asset.id, stemType: 'bass', path: dest, origin: 'mvsep' }));
+        return rows;
+    }
+    // drumsep: kick, snare, toms + the full drums bus → hats by phase cancel.
+    const kickFile = join(stemsDir, 'kick.wav');
+    const snareFile = join(stemsDir, 'snare.wav');
+    const tomsFile = join(stemsDir, 'toms.wav');
+    const drumsBusFile = join(stemsDir, 'drums-bus.wav');
+    await Promise.all([
+        downloadTo(pickFile(files, (n) => /kick/.test(n)), kickFile),
+        downloadTo(pickFile(files, (n) => /snare/.test(n)), snareFile),
+        downloadTo(pickFile(files, (n) => /tom/.test(n)), tomsFile),
+        downloadTo(pickFile(files, (n) => /drums\.wav/.test(n)), drumsBusFile)
+    ]);
+    rows.push(upsertStem({ projectId, assetId: asset.id, stemType: 'kick', path: kickFile, origin: 'mvsep' }));
+    rows.push(upsertStem({ projectId, assetId: asset.id, stemType: 'snare', path: snareFile, origin: 'mvsep' }));
+    rows.push(upsertStem({ projectId, assetId: asset.id, stemType: 'toms', path: tomsFile, origin: 'mvsep' }));
+    // hats = drums − kick − snare − toms (only needs this job's files).
+    const [drumsBus, kick, snare, toms] = await Promise.all([
+        decodeWavFile(drumsBusFile),
+        decodeWavFile(kickFile),
+        decodeWavFile(snareFile),
+        decodeWavFile(tomsFile)
+    ]);
+    const hats = subtractWavs(drumsBus, kick, snare, toms);
+    const hatsFile = join(stemsDir, 'hats.wav');
+    await encodeWavFloat32File(hatsFile, hats.channels, hats.sampleRate);
+    rows.push(upsertStem({ projectId, assetId: asset.id, stemType: 'hats', path: hatsFile, origin: 'synthesized' }));
+    return rows;
+}
+/** Final step once ALL THREE jobs have landed: synthesize ee
+ *  (original − vocals − drums-bus − bass), then drop the drums-bus intermediate. */
+export async function finalizeSplit(asset, stemsDir) {
+    const originalPath = join(stemsDir, 'original.wav');
+    const drumsBusFile = join(stemsDir, 'drums-bus.wav');
+    const [original, vocals, drumsBus, bass] = await Promise.all([
+        decodeWavFile(originalPath),
+        decodeWavFile(join(stemsDir, 'vocals.wav')),
+        decodeWavFile(drumsBusFile),
+        decodeWavFile(join(stemsDir, 'bass.wav'))
+    ]);
+    const ee = subtractWavs(original, vocals, drumsBus, bass);
+    const eeFile = join(stemsDir, 'ee.wav');
+    await encodeWavFloat32File(eeFile, ee.channels, ee.sampleRate);
+    const row = upsertStem({
+        projectId: asset.projectId,
+        assetId: asset.id,
+        stemType: 'ee',
+        path: eeFile,
+        origin: 'synthesized'
+    });
+    await unlink(drumsBusFile).catch(() => { });
+    return row;
+}
+/** Blocking end-to-end split with progressive landing — each job's stems
+ *  register as that job finishes. Returns all 7 stem rows. */
+export async function runSplitBlocking(assetId, onProgress) {
+    onProgress?.('Standardizing audio');
+    const prep = await prepareSplit(assetId);
+    onProgress?.('Submitting 3 MVSEP jobs');
+    const hashes = await createSplitJobs(prep.audioBytes);
+    const rows = [];
+    const land = async (job) => {
+        const files = await awaitSeparationResult({ hash: hashes[job] }, (s) => onProgress?.(`${job}: ${s}`));
+        onProgress?.(`${job}: downloading stems`);
+        rows.push(...(await landSplitJob(job, files, prep.asset, prep.stemsDir)));
+        onProgress?.(`${job}: landed`);
+    };
+    await Promise.all([land('vocals'), land('drumsep'), land('bass')]);
+    onProgress?.('Synthesizing everything-else (ee)');
+    rows.push(await finalizeSplit(prep.asset, prep.stemsDir));
+    onProgress?.('Split complete');
+    return rows;
+}
+//# sourceMappingURL=split.js.map

package/dist/stack.d.ts

@@ -0,0 +1,19 @@
+import type { StackLane } from './types.js';
+export declare function loadStack(projectId: string): Promise<StackLane[]>;
+export declare function saveStack(projectId: string, lanes: StackLane[]): Promise<void>;
+export declare function addLane(projectId: string, lane: {
+    name: string;
+    path: string;
+    sourceId?: string;
+    color?: string;
+    offsetSec?: number;
+    gainDb?: number;
+}): Promise<StackLane>;
+export declare function updateLane(projectId: string, laneId: string, patch: Partial<Pick<StackLane, 'offsetSec' | 'gainDb' | 'mute' | 'solo' | 'name'>>): Promise<StackLane>;
+export declare function removeLane(projectId: string, laneId: string): Promise<void>;
+/** Export one padded 32f WAV per audible lane into <project>/stack-export/.
+ *  Non-WAV / non-44.1k lanes are standardized first (the renderer's
+ *  decodeAudioData resamples to the 44.1k context; ffmpeg does it here). */
+export declare function exportStackBundle(projectId: string): Promise<string[]>;
+/** Resolve a friendly lane name for an audio path (filename sans extension). */
+export declare function laneNameFromPath(path: string): string;

package/dist/stack.js

@@ -0,0 +1,139 @@
+// Stack (minimal layer view) — file-level port. stack.json lives in the project
+// folder (same shape the app's stackStore persists), and the export-bundle math
+// is the Node port of stackStore.exportBundle: one 32-bit float WAV per audible
+// lane, padded with leading silence to common timeline zero (sample-accurate
+// offset rounding, gain baked in, muted/solo-excluded lanes skipped).
+import { join, basename, extname } from 'node:path';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { v4 as uuidv4 } from 'uuid';
+import { getProjectDirectory } from './storage/projects.js';
+import { standardizeToWav } from './audio/ffmpeg.js';
+import { decodeWavFile, encodeWavFloat32File } from './audio/wav.js';
+const SAMPLE_RATE = 44100;
+function stackPath(projectId) {
+    return join(getProjectDirectory(projectId), 'stack.json');
+}
+export async function loadStack(projectId) {
+    const file = stackPath(projectId);
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(await readFile(file, 'utf-8'));
+        return Array.isArray(parsed.lanes) ? parsed.lanes : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveStack(projectId, lanes) {
+    const dir = getProjectDirectory(projectId);
+    await mkdir(dir, { recursive: true });
+    await writeFile(stackPath(projectId), JSON.stringify({ lanes }, null, 2));
+}
+export async function addLane(projectId, lane) {
+    if (!existsSync(lane.path))
+        throw new Error(`Lane audio file not found: ${lane.path}`);
+    const lanes = await loadStack(projectId);
+    const full = {
+        id: uuidv4(),
+        sourceId: lane.sourceId,
+        name: lane.name,
+        path: lane.path,
+        color: lane.color,
+        gainDb: lane.gainDb ?? 0,
+        mute: false,
+        solo: false,
+        offsetSec: Math.max(0, lane.offsetSec ?? 0)
+    };
+    lanes.push(full);
+    await saveStack(projectId, lanes);
+    return full;
+}
+export async function updateLane(projectId, laneId, patch) {
+    const lanes = await loadStack(projectId);
+    const lane = lanes.find((l) => l.id === laneId);
+    if (!lane)
+        throw new Error(`Lane not found: ${laneId}`);
+    if (patch.offsetSec !== undefined)
+        lane.offsetSec = Math.max(0, patch.offsetSec);
+    if (patch.gainDb !== undefined)
+        lane.gainDb = patch.gainDb;
+    if (patch.mute !== undefined)
+        lane.mute = patch.mute;
+    if (patch.solo !== undefined)
+        lane.solo = patch.solo;
+    if (patch.name !== undefined)
+        lane.name = patch.name;
+    await saveStack(projectId, lanes);
+    return lane;
+}
+export async function removeLane(projectId, laneId) {
+    const lanes = await loadStack(projectId);
+    await saveStack(projectId, lanes.filter((l) => l.id !== laneId));
+}
+function dbToLin(db) {
+    return Math.pow(10, db / 20);
+}
+function sanitize(name) {
+    return name.replace(/[\\/:*?"<>|]/g, '_').trim() || 'lane';
+}
+/** Export one padded 32f WAV per audible lane into <project>/stack-export/.
+ *  Non-WAV / non-44.1k lanes are standardized first (the renderer's
+ *  decodeAudioData resamples to the 44.1k context; ffmpeg does it here). */
+export async function exportStackBundle(projectId) {
+    const lanes = await loadStack(projectId);
+    if (lanes.length === 0)
+        throw new Error('Stack is empty — add lanes before exporting.');
+    const anySolo = lanes.some((l) => l.solo);
+    const audible = lanes.filter((l) => !(l.mute || (anySolo && !l.solo)));
+    if (audible.length === 0)
+        throw new Error('No audible lanes (everything muted or solo-excluded).');
+    const exportDir = join(getProjectDirectory(projectId), 'stack-export');
+    await mkdir(exportDir, { recursive: true });
+    const paths = [];
+    const cleanups = [];
+    try {
+        for (const lane of audible) {
+            if (!existsSync(lane.path)) {
+                throw new Error(`Lane "${lane.name}" points at a missing file: ${lane.path}`);
+            }
+            let wavSource = lane.path;
+            if (extname(lane.path).toLowerCase() !== '.wav') {
+                wavSource = join(tmpdir(), `aurora-stack-${uuidv4()}.wav`);
+                await standardizeToWav(lane.path, wavSource);
+                cleanups.push(wavSource);
+            }
+            let decoded = await decodeWavFile(wavSource);
+            if (decoded.sampleRate !== SAMPLE_RATE) {
+                const resampled = join(tmpdir(), `aurora-stack-${uuidv4()}.wav`);
+                await standardizeToWav(wavSource, resampled);
+                cleanups.push(resampled);
+                decoded = await decodeWavFile(resampled);
+            }
+            const offsetSamples = Math.round(lane.offsetSec * decoded.sampleRate);
+            const totalLength = offsetSamples + decoded.frames;
+            const lin = dbToLin(lane.gainDb);
+            const out = decoded.channels.map((src) => {
+                const dst = new Float32Array(totalLength);
+                for (let i = 0; i < src.length; i++)
+                    dst[offsetSamples + i] = src[i] * lin;
+                return dst;
+            });
+            const dest = join(exportDir, `${sanitize(lane.name)}.wav`);
+            await encodeWavFloat32File(dest, out, decoded.sampleRate);
+            paths.push(dest);
+        }
+    }
+    finally {
+        for (const f of cleanups)
+            await rm(f, { force: true }).catch(() => { });
+    }
+    return paths;
+}
+/** Resolve a friendly lane name for an audio path (filename sans extension). */
+export function laneNameFromPath(path) {
+    return basename(path, extname(path));
+}
+//# sourceMappingURL=stack.js.map

package/dist/storage/assets.d.ts

@@ -0,0 +1,30 @@
+import type { AssetKind, ProjectAsset } from '../types.js';
+export declare function listAssets(projectId: string): ProjectAsset[];
+export declare function getAsset(id: string): ProjectAsset | null;
+/** The kind subfolder inside the project dir, created on demand. */
+export declare function ensureKindDir(projectId: string, kind: AssetKind): Promise<string>;
+/** Where an asset's split stems land: <project>/stems/<asset-slug>-<shortid>/. */
+export declare function getAssetStemsDir(asset: ProjectAsset): string;
+/** Non-clobbering destination filename inside a kind dir. */
+export declare function uniqueDestPath(dir: string, fileName: string): string;
+export declare function insertAsset(params: {
+    projectId: string;
+    kind: AssetKind;
+    name: string;
+    path: string;
+    origin?: unknown;
+    sourceAssetId?: string | null;
+    refId?: string | null;
+}): ProjectAsset;
+/** Copy an external file into the project as an import or reference asset.
+ *  References ALSO get a reference_tracks row (the global curve cache). */
+export declare function addFileAsset(params: {
+    projectId: string;
+    kind: 'import' | 'reference';
+    filePath: string;
+}): Promise<ProjectAsset>;
+/** Point an asset at a new file (e.g. after a WAV fetch upgrades the MP3). */
+export declare function updateAssetPath(id: string, path: string): ProjectAsset;
+/** Delete an asset: row, stems rows, its audio file, its stems folder, and its
+ *  linked reference row if any. */
+export declare function deleteAsset(id: string): Promise<void>;

package/dist/storage/assets.js

@@ -0,0 +1,103 @@
+// Port of aurora/src/main/storage/assets.ts — identical kind subfolders, asset
+// rows, stems-dir naming, and delete semantics.
+import { join, basename, extname } from 'node:path';
+import { mkdir, rm, copyFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { v4 as uuidv4 } from 'uuid';
+import { getDb } from '../db.js';
+import { getProjectDirectory, slugify, touchProject } from './projects.js';
+import { addReference, deleteReference } from './references.js';
+const KIND_DIRS = {
+    generation: 'generations',
+    cover: 'covers',
+    import: 'imports',
+    reference: 'references',
+    master: 'masters'
+};
+function rowToAsset(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        kind: row.kind,
+        name: row.name,
+        path: row.path,
+        origin: row.origin ? JSON.parse(row.origin) : null,
+        sourceAssetId: row.source_asset_id,
+        refId: row.ref_id,
+        createdAt: row.created_at
+    };
+}
+export function listAssets(projectId) {
+    const rows = getDb()
+        .prepare('SELECT * FROM project_assets WHERE project_id = ? ORDER BY created_at DESC')
+        .all(projectId);
+    return rows.map(rowToAsset);
+}
+export function getAsset(id) {
+    const row = getDb().prepare('SELECT * FROM project_assets WHERE id = ?').get(id);
+    return row ? rowToAsset(row) : null;
+}
+/** The kind subfolder inside the project dir, created on demand. */
+export async function ensureKindDir(projectId, kind) {
+    const dir = join(getProjectDirectory(projectId), KIND_DIRS[kind]);
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+/** Where an asset's split stems land: <project>/stems/<asset-slug>-<shortid>/. */
+export function getAssetStemsDir(asset) {
+    return join(getProjectDirectory(asset.projectId), 'stems', `${slugify(asset.name, 40)}-${asset.id.slice(0, 6)}`);
+}
+/** Non-clobbering destination filename inside a kind dir. */
+export function uniqueDestPath(dir, fileName) {
+    const ext = extname(fileName);
+    const stem = basename(fileName, ext);
+    let candidate = join(dir, fileName);
+    for (let i = 2; existsSync(candidate); i++) {
+        candidate = join(dir, `${stem}-${i}${ext}`);
+    }
+    return candidate;
+}
+export function insertAsset(params) {
+    const id = uuidv4();
+    getDb()
+        .prepare(`INSERT INTO project_assets (id, project_id, kind, name, path, origin, source_asset_id, ref_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, params.projectId, params.kind, params.name, params.path, params.origin ? JSON.stringify(params.origin) : null, params.sourceAssetId ?? null, params.refId ?? null, Date.now());
+    touchProject(params.projectId);
+    return getAsset(id);
+}
+/** Copy an external file into the project as an import or reference asset.
+ *  References ALSO get a reference_tracks row (the global curve cache). */
+export async function addFileAsset(params) {
+    const dir = await ensureKindDir(params.projectId, params.kind);
+    const dest = uniqueDestPath(dir, basename(params.filePath));
+    await copyFile(params.filePath, dest);
+    const name = basename(dest, extname(dest));
+    let refId = null;
+    if (params.kind === 'reference') {
+        const ref = await addReference(dest, { copy: false });
+        refId = ref.id;
+    }
+    return insertAsset({ projectId: params.projectId, kind: params.kind, name, path: dest, refId });
+}
+/** Point an asset at a new file (e.g. after a WAV fetch upgrades the MP3). */
+export function updateAssetPath(id, path) {
+    getDb().prepare('UPDATE project_assets SET path = ? WHERE id = ?').run(path, id);
+    return getAsset(id);
+}
+/** Delete an asset: row, stems rows, its audio file, its stems folder, and its
+ *  linked reference row if any. */
+export async function deleteAsset(id) {
+    const asset = getAsset(id);
+    if (!asset)
+        return;
+    const db = getDb();
+    db.prepare('DELETE FROM project_stems WHERE asset_id = ?').run(id);
+    db.prepare('DELETE FROM project_assets WHERE id = ?').run(id);
+    await rm(asset.path, { force: true }).catch(() => { });
+    await rm(getAssetStemsDir(asset), { recursive: true, force: true }).catch(() => { });
+    if (asset.refId)
+        await deleteReference(asset.refId).catch(() => { });
+    touchProject(asset.projectId);
+}
+//# sourceMappingURL=assets.js.map

package/dist/storage/projects.d.ts

@@ -0,0 +1,12 @@
+import type { Project } from '../types.js';
+/** Filesystem-safe slug for human-readable project folders. */
+export declare function slugify(input: string, max?: number): string;
+/** Absolute path to a project's directory. Legacy projects use their uuid dir. */
+export declare function getProjectDirectory(projectId: string): string;
+export declare function listProjects(): Project[];
+export declare function getProject(id: string): Project | null;
+export declare function createProject(name: string): Promise<Project>;
+/** Rename the project (DB name only — the on-disk folder keeps its name). */
+export declare function renameProject(id: string, name: string): Project;
+export declare function touchProject(id: string): void;
+export declare function deleteProject(id: string): Promise<void>;