videobook 0.0.0-stage → 0.2.0

package/dist/remotion/util.js

@@ -0,0 +1,18 @@
+export function isValidHex(hex) {
+    return /^#[0-9a-fA-F]{6}$/.test(hex);
+}
+export function getCurrentWordIndex(words, currentTime, lingerDuration = 0) {
+    for (let i = 0; i < words.length; i++) {
+        let wordEnd = words[i].end;
+        if (lingerDuration > 0 && i + 1 < words.length) {
+            wordEnd = Math.min(wordEnd + lingerDuration, words[i + 1].start - 0.01);
+        }
+        else if (lingerDuration > 0) {
+            wordEnd = wordEnd + lingerDuration;
+        }
+        if (words[i].start <= currentTime && currentTime <= wordEnd) {
+            return i;
+        }
+    }
+    return -1;
+}

package/dist/remotion-cancellation.js

@@ -0,0 +1,15 @@
+import { makeCancelSignal } from "@remotion/renderer";
+export async function withRemotionCancellation(signal, render) {
+    signal.throwIfAborted();
+    const { cancelSignal, cancel } = makeCancelSignal();
+    const abort = () => cancel();
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+        const result = await render(cancelSignal);
+        signal.throwIfAborted();
+        return result;
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+    }
+}

package/dist/rename-helpers.js

@@ -0,0 +1,204 @@
+/** Asset kinds eligible for rename-all (matches the preview scope). */
+export const RENAME_KINDS = ["video", "image"];
+export function isRenamableKind(kind) {
+    return RENAME_KINDS.some((candidate) => candidate === kind);
+}
+function rowKind(kind) {
+    return kind === "video" ? "video" : "image";
+}
+function displayName(label, artifactId) {
+    return label ?? artifactId;
+}
+/** Build the user-visible rows from the AI suggestion map, marking skipped and
+ *  unchanged rows. `suggestions` maps asset_id → proposed label. Labels are
+ *  free text with no uniqueness constraint, so there are no collisions to
+ *  resolve. */
+export function buildRenameRows(assets, suggestions) {
+    const rows = [];
+    for (const asset of assets) {
+        const currentName = displayName(asset.label, asset.asset_id);
+        const proposed = suggestions[asset.asset_id]?.trim();
+        if (!proposed) {
+            rows.push({
+                asset_id: asset.asset_id,
+                type: rowKind(asset.type),
+                current_name: currentName,
+                suggested_name: currentName,
+                status: "skipped",
+                reason: "No suggestion produced",
+            });
+            continue;
+        }
+        if (proposed === asset.label) {
+            rows.push({
+                asset_id: asset.asset_id,
+                type: rowKind(asset.type),
+                current_name: currentName,
+                suggested_name: proposed,
+                status: "unchanged",
+                reason: "Label already matches",
+            });
+            continue;
+        }
+        rows.push({
+            asset_id: asset.asset_id,
+            type: rowKind(asset.type),
+            current_name: currentName,
+            suggested_name: proposed,
+            status: "renamable",
+        });
+    }
+    return rows;
+}
+/** Revalidate a user-edited set of renames against the live asset list. This
+ *  is the dry-run-with-edits path: assets may have been deleted or relabeled
+ *  since the suggestion pass, so every row is rechecked. */
+export function validateEditedRenames(edits, candidates) {
+    const byId = new Map(candidates.map((candidate) => [candidate.artifactId, candidate]));
+    const rows = [];
+    for (const edit of edits) {
+        const candidate = byId.get(edit.asset_id);
+        const trimmed = edit.suggested_name.trim();
+        if (!candidate) {
+            rows.push({
+                asset_id: edit.asset_id,
+                type: "image",
+                current_name: edit.asset_id,
+                suggested_name: edit.suggested_name,
+                status: "conflict",
+                reason: "Asset no longer exists",
+            });
+            continue;
+        }
+        const currentName = displayName(candidate.label, candidate.artifactId);
+        if (!isRenamableKind(candidate.kind)) {
+            rows.push({
+                asset_id: edit.asset_id,
+                type: rowKind(candidate.kind),
+                current_name: currentName,
+                suggested_name: edit.suggested_name,
+                status: "conflict",
+                reason: `Only video and image assets are renamable here (got ${candidate.kind})`,
+            });
+            continue;
+        }
+        if (!trimmed) {
+            rows.push({
+                asset_id: edit.asset_id,
+                type: rowKind(candidate.kind),
+                current_name: currentName,
+                suggested_name: edit.suggested_name,
+                status: "conflict",
+                reason: "Empty name",
+            });
+            continue;
+        }
+        if (trimmed === candidate.label) {
+            rows.push({
+                asset_id: edit.asset_id,
+                type: rowKind(candidate.kind),
+                current_name: currentName,
+                suggested_name: trimmed,
+                status: "unchanged",
+                reason: "Label already matches",
+            });
+            continue;
+        }
+        rows.push({
+            asset_id: edit.asset_id,
+            type: rowKind(candidate.kind),
+            current_name: currentName,
+            suggested_name: trimmed,
+            status: "renamable",
+        });
+    }
+    return rows;
+}
+/** Rows that will actually be relabeled at apply time. */
+export function applyableRows(rows) {
+    return rows.filter((r) => r.status === "renamable");
+}
+// --- GPT prompt construction (pure) -----------------------------------------
+/** Origins that describe how an image was produced, not what it shows. */
+const PROCESS_ORIGINS = new Set([
+    "first_frame",
+    "last_frame",
+    "custom_frame",
+    "external",
+    "upload",
+    "apply_cuts",
+]);
+/** Whether a metadata origin is a process label (useless alone for naming). */
+export function isProcessOrigin(origin) {
+    return PROCESS_ORIGINS.has(origin.trim().toLowerCase());
+}
+/** Build the single GPT-5.5 user message requesting a JSON map of
+ *  asset_id → short descriptive label. Kept pure for unit testing.
+ *  When `hasImages` is true, the message notes that preview frames follow. */
+export function buildSuggestionPrompt(assets, opts = {}) {
+    const entries = assets.map((a) => {
+        const current = a.label ? `; current label: ${a.label}` : "";
+        const heading = `${a.asset_id} (${a.type}${current})`;
+        const snippet = a.context_text.slice(0, 700).replace(/\s+/g, " ").trim();
+        return snippet
+            ? `- ${heading}: ${snippet}`
+            : `- ${heading}: (no text context — use the preview image)`;
+    });
+    const imageNote = opts.hasImages
+        ? [
+            "Preview images follow this list: for each asset_id, one or more stills",
+            "(videos: first frame then last frame; images: the image itself).",
+            "Prefer what you SEE in the previews over process labels in the text.",
+            "",
+        ]
+        : [];
+    return [
+        "You label video and image assets in a creative project so their display",
+        "labels describe their VISUAL content. For each asset, propose a VERY SHORT",
+        "label: prefer 1–2 content words (3 max). Think folder tags, not sentences.",
+        "",
+        "Rules:",
+        "- Name the main subject or prop only (e.g. \"gadget pitch\", \"green device\").",
+        "- Prefer concrete nouns over adjectives, settings, or abstract process words.",
+        "- Do NOT invent details absent from the context text and preview images.",
+        "- Do NOT name after pipeline/meta labels: last frame, first frame, update,",
+        "  device image, locked off, fixed camera, external, upload, edit, regenerate.",
+        "- Do NOT copy typo-ridden edit prompts (\"updat ethe device...\") — describe",
+        "  the resulting image instead.",
+        "- Prefer analysis/summary/visual cues over raw transcript; use spoken words",
+        "  only when they name a distinctive prop or topic (e.g. a product brand).",
+        "- Make labels distinct within this batch when assets look different.",
+        "- Keep labels lowercase plain words (no punctuation, no artifact ids).",
+        "",
+        ...imageNote,
+        "Return ONLY a JSON object mapping each asset_id to the proposed label.",
+        "Example: {\"0198f9a2-…\": \"gadget pitch\", \"0198f9a3-…\": \"green device\"}",
+        "",
+        "Assets:",
+        ...entries,
+    ].join("\n");
+}
+/** Parse the GPT JSON response into an asset_id → label map, tolerating a
+ *  leading code-fence or surrounding prose. Returns empty map on failure. */
+export function parseSuggestionResponse(text) {
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const candidate = fenceMatch ? fenceMatch[1] : text;
+    const objStart = candidate.indexOf("{");
+    const objEnd = candidate.lastIndexOf("}");
+    if (objStart === -1 || objEnd === -1 || objEnd <= objStart)
+        return {};
+    try {
+        const parsed = JSON.parse(candidate.slice(objStart, objEnd + 1));
+        if (typeof parsed !== "object" || parsed === null)
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === "string")
+                out[k] = v;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}

package/dist/rhythm/analyze.js

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { createOnsetAccumulator } from "./onset.js";
+import { trackBeats } from "./track.js";
+import { RHYTHM_SAMPLE_RATE, } from "./contract.js";
+const YIELD_EVERY_HOPS = 96;
+async function yieldToEventLoop() {
+    await new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}
+function startEventLoopProbe(intervalMs = 20) {
+    let maxLag = 0;
+    let previous = Date.now();
+    const timer = setInterval(() => {
+        const now = Date.now();
+        maxLag = Math.max(maxLag, now - previous - intervalMs);
+        previous = now;
+    }, intervalMs);
+    return {
+        stop() {
+            clearInterval(timer);
+            return Math.max(0, maxLag, Date.now() - previous - intervalMs);
+        },
+    };
+}
+async function analyzePcmStream(chunks, options = {}) {
+    const sampleRate = options.sampleRate ?? RHYTHM_SAMPLE_RATE;
+    const accumulator = createOnsetAccumulator(sampleRate);
+    const probe = startEventLoopProbe();
+    let peakRss = process.memoryUsage().rss;
+    let yieldedAt = 0;
+    let samples = 0;
+    try {
+        for await (const chunk of chunks) {
+            options.signal?.throwIfAborted();
+            accumulator.push(chunk);
+            samples += chunk.length;
+            if (samples > sampleRate * 60 * 60)
+                throw new Error("Music analysis supports up to 60 minutes");
+            peakRss = Math.max(peakRss, process.memoryUsage().rss);
+            const hops = accumulator.hopCount();
+            if (hops - yieldedAt >= YIELD_EVERY_HOPS) {
+                yieldedAt = hops;
+                await yieldToEventLoop();
+                peakRss = Math.max(peakRss, process.memoryUsage().rss);
+            }
+        }
+        options.signal?.throwIfAborted();
+        const analysis = trackBeats(accumulator.finish());
+        analysis.resources = resources(Math.max(peakRss, process.memoryUsage().rss), probe.stop(), accumulator.retainedSamples(), samples / sampleRate);
+        return analysis;
+    }
+    catch (error) {
+        probe.stop();
+        throw error;
+    }
+}
+export async function analyzePcm(samples, sampleRate = RHYTHM_SAMPLE_RATE, signal) {
+    async function* once() {
+        const slice = Math.max(sampleRate, 1);
+        for (let offset = 0; offset < samples.length; offset += slice) {
+            yield samples.subarray(offset, Math.min(samples.length, offset + slice));
+        }
+    }
+    return analyzePcmStream(once(), { sampleRate, signal });
+}
+async function* decodeAudioToPcm(ffmpegPath, inputPath, signal, streamIndex) {
+    signal?.throwIfAborted();
+    const child = spawn(ffmpegPath, [
+        "-v", "error",
+        "-i", inputPath,
+        "-map", streamIndex === undefined ? "0:a:0" : `0:${streamIndex}`, "-vn", "-ac", "1",
+        "-ar", String(RHYTHM_SAMPLE_RATE),
+        "-f", "f32le",
+        "pipe:1",
+    ], { stdio: ["ignore", "pipe", "pipe"] });
+    const stderr = [];
+    let errorBytes = 0;
+    child.stderr?.on("data", (chunk) => {
+        if (errorBytes < 8192)
+            stderr.push(chunk.subarray(0, 8192 - errorBytes));
+        errorBytes += chunk.length;
+    });
+    const closed = new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code) => resolve(code ?? 1));
+    });
+    void closed.catch(() => undefined);
+    let pending = Buffer.alloc(0);
+    const abort = () => {
+        child.kill("SIGTERM");
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    let drained = false;
+    try {
+        for await (const chunk of child.stdout ?? []) {
+            if (signal?.aborted)
+                break;
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            const combined = pending.length === 0 ? bytes : Buffer.concat([pending, bytes]);
+            const sampleCount = Math.floor(combined.length / 4);
+            const pcm = new Float32Array(sampleCount);
+            for (let index = 0; index < sampleCount; index += 1) {
+                pcm[index] = combined.readFloatLE(index * 4);
+            }
+            pending = Buffer.from(combined.subarray(sampleCount * 4));
+            if (pcm.length > 0)
+                yield pcm;
+        }
+        drained = true;
+    }
+    finally {
+        signal?.removeEventListener("abort", abort);
+        if (!drained && child.exitCode === null)
+            child.kill("SIGTERM");
+    }
+    const exitCode = await closed;
+    signal?.throwIfAborted();
+    if (exitCode !== 0) {
+        throw new Error(`ffmpeg decode failed (${exitCode}): ${Buffer.concat(stderr).toString("utf8")}`);
+    }
+}
+export async function analyzeAudioFile(ffmpegPath, inputPath, signal, streamIndex) {
+    return analyzePcmStream(decodeAudioToPcm(ffmpegPath, inputPath, signal, streamIndex), { signal });
+}
+function resources(peakRssBytes, maxEventLoopLagMs, pcmRetainedSamples, durationSeconds) {
+    return { peakRssBytes, maxEventLoopLagMs, pcmRetainedSamples, durationSeconds };
+}

package/dist/rhythm/contract.js

@@ -0,0 +1,14 @@
+export const RHYTHM_ANALYZER_ID = "videobook-spectral-flux-dp";
+export const RHYTHM_ANALYZER_VERSION = "4";
+export const RHYTHM_SCHEMA_VERSION = 1;
+export const RHYTHM_SAMPLE_RATE = 22_050;
+export const RHYTHM_WINDOW_SAMPLES = 1_024;
+export const RHYTHM_HOP_SAMPLES = 256;
+export const RHYTHM_LATENCY_SAMPLES = RHYTHM_WINDOW_SAMPLES / 2;
+export const RHYTHM_MAX_RETAINED_SAMPLES = RHYTHM_WINDOW_SAMPLES + RHYTHM_HOP_SAMPLES;
+export const ENERGY_ALGORITHM_ID = "videobook-rms-energy";
+export const ENERGY_ALGORITHM_VERSION = "1";
+export const SECTION_DETECTOR_ID = "videobook-energy-sections";
+export const SECTION_DETECTOR_VERSION = "1";
+export const SECTION_LABELER_ID = "videobook-section-labeler";
+export const SECTION_LABELER_VERSION = "1";

package/dist/rhythm/draft-model.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export const musicDraftOptionsSchema = z.object({
+    track_id: z.string().uuid(),
+    start_frame: z.number().int().nonnegative(),
+    end_frame: z.number().int().positive(),
+    sources: z.array(z.object({ artifact_id: z.string().uuid(), start_seconds: z.number().nonnegative().optional(), end_seconds: z.number().positive().optional() })).min(1).max(100),
+    interval: z.union([z.literal(1), z.literal(2), z.literal(4), z.literal(8)]),
+    unit: z.enum(["beats", "bars"]),
+    minimum_shot_frames: z.number().int().positive(),
+    preserve_existing: z.boolean().default(true),
+    preserve_clip_ids: z.array(z.string().uuid()).default([]),
+    reuse_sources: z.boolean().default(false),
+    allow_retiming: z.boolean().default(false),
+    strategy: z.enum(["beat_interval", "follow_song_energy"]).default("beat_interval"),
+    analysis: z.object({
+        music_analysis_id: z.string().min(1),
+        moments: z.array(z.object({ artifact_id: z.string().uuid(), moments_id: z.string().min(1) })).max(24).optional(),
+    }).optional(),
+});

package/dist/rhythm/energy.js

@@ -0,0 +1,133 @@
+import { ENERGY_ALGORITHM_ID, ENERGY_ALGORITHM_VERSION, SECTION_DETECTOR_ID, SECTION_DETECTOR_VERSION, } from "./contract.js";
+const ENERGY_BIN_SECONDS = 0.25;
+const SECTION_SMOOTH_SECONDS = 2;
+const SECTION_RADIUS_SECONDS = 1.5;
+const SECTION_MIN_GAP_SECONDS = 8;
+const SECTION_MIN_NOVELTY = 0.12;
+const TIER_SPREAD = 0.15;
+const round = (value) => Math.round(value * 10000) / 10000;
+export function energyCurve(envelope) {
+    const frameSeconds = envelope.hopSamples / envelope.sampleRate;
+    const binFrames = Math.max(1, Math.round(ENERGY_BIN_SECONDS / frameSeconds));
+    const raw = [];
+    let peak = 0;
+    for (let start = 0; start < envelope.frameCount; start += binFrames) {
+        const end = Math.min(envelope.frameCount, start + binFrames);
+        let sum = 0;
+        for (let index = start; index < end; index += 1)
+            sum += envelope.rms[index] ?? 0;
+        const mean = sum / (end - start);
+        raw.push(mean);
+        if (mean > peak)
+            peak = mean;
+    }
+    return {
+        algorithmId: ENERGY_ALGORITHM_ID,
+        algorithmVersion: ENERGY_ALGORITHM_VERSION,
+        hopSeconds: round(binFrames * frameSeconds),
+        values: raw.map((value) => round(peak > 0 ? value / peak : 0)),
+    };
+}
+export function candidateSections(energy, durationSeconds) {
+    const binSeconds = energy.hopSeconds;
+    const smoothWidth = Math.max(1, 2 * Math.round(SECTION_SMOOTH_SECONDS / binSeconds / 2) + 1);
+    const radius = Math.max(1, Math.round(SECTION_RADIUS_SECONDS / binSeconds));
+    const smooth = movingAverage(energy.values, smoothWidth);
+    const novelty = new Array(energy.values.length).fill(0);
+    for (let index = radius; index < energy.values.length - radius; index += 1) {
+        novelty[index] = Math.abs(smooth[index + radius] - smooth[index - radius]);
+    }
+    const threshold = Math.max(SECTION_MIN_NOVELTY, 0.6 * quantile(novelty, 0.9));
+    const peaks = [];
+    for (let index = 1; index < novelty.length - 1; index += 1) {
+        const value = novelty[index];
+        if (value < threshold)
+            continue;
+        if (value < novelty[index - 1] || value < novelty[index + 1])
+            continue;
+        const timeSeconds = index * binSeconds;
+        if (timeSeconds < SECTION_RADIUS_SECONDS || timeSeconds > durationSeconds - SECTION_RADIUS_SECONDS)
+            continue;
+        peaks.push({ timeSeconds, novelty: value });
+    }
+    peaks.sort((left, right) => right.novelty - left.novelty || left.timeSeconds - right.timeSeconds);
+    const kept = [];
+    for (const peak of peaks) {
+        if (kept.every((entry) => Math.abs(entry.timeSeconds - peak.timeSeconds) >= SECTION_MIN_GAP_SECONDS)) {
+            kept.push(peak);
+        }
+    }
+    kept.sort((left, right) => left.timeSeconds - right.timeSeconds);
+    return {
+        algorithmId: SECTION_DETECTOR_ID,
+        algorithmVersion: SECTION_DETECTOR_VERSION,
+        candidates: kept.map((entry, index) => ({
+            id: `section-${index + 1}`,
+            timeSeconds: round(entry.timeSeconds),
+            quality: round(Math.min(1, entry.novelty / (2 * threshold))),
+        })),
+    };
+}
+function sampleEnergy(energy, timeSeconds) {
+    if (!energy.values.length)
+        return 0;
+    const index = Math.min(energy.values.length - 1, Math.max(0, Math.floor(timeSeconds / energy.hopSeconds)));
+    return energy.values[index] ?? 0;
+}
+export function energySegments(energy, sections, durationSeconds) {
+    if (!(durationSeconds > 0))
+        return [];
+    const bounds = [0, ...(sections?.candidates ?? []).map((candidate) => candidate.timeSeconds), durationSeconds]
+        .filter((value, index, all) => value >= 0 && value <= durationSeconds && (index === 0 || value > all[index - 1]));
+    if (bounds.length < 2)
+        return [];
+    const segments = bounds.slice(0, -1).map((start, index) => {
+        const end = bounds[index + 1];
+        return { startSeconds: start, endSeconds: end, meanEnergy: meanEnergy(energy, start, end), tier: "mid" };
+    });
+    const baseline = median(segments.map((segment) => segment.meanEnergy));
+    if (baseline > 0) {
+        for (const segment of segments) {
+            segment.tier = segment.meanEnergy >= baseline * (1 + TIER_SPREAD) ? "high"
+                : segment.meanEnergy <= baseline * (1 - TIER_SPREAD) ? "low" : "mid";
+        }
+    }
+    return segments;
+}
+function meanEnergy(energy, startSeconds, endSeconds) {
+    const first = Math.max(0, Math.floor(startSeconds / energy.hopSeconds));
+    const last = Math.min(energy.values.length, Math.ceil(endSeconds / energy.hopSeconds));
+    if (last <= first)
+        return sampleEnergy(energy, (startSeconds + endSeconds) / 2);
+    let sum = 0;
+    for (let index = first; index < last; index += 1)
+        sum += energy.values[index] ?? 0;
+    return round(sum / (last - first));
+}
+function movingAverage(values, width) {
+    const half = Math.floor(width / 2);
+    const result = new Array(values.length).fill(0);
+    for (let index = 0; index < values.length; index += 1) {
+        const start = Math.max(0, index - half);
+        const end = Math.min(values.length, index + half + 1);
+        let sum = 0;
+        for (let cursor = start; cursor < end; cursor += 1)
+            sum += values[cursor] ?? 0;
+        result[index] = sum / (end - start);
+    }
+    return result;
+}
+function quantile(values, share) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((left, right) => left - right);
+    const position = Math.min(sorted.length - 1, Math.max(0, Math.floor(share * sorted.length)));
+    return sorted[position] ?? 0;
+}
+function median(values) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((left, right) => left - right);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2 : sorted[middle] ?? 0;
+}

package/dist/rhythm/fft.js

@@ -0,0 +1,44 @@
+export function fftInPlace(real, imag) {
+    const n = real.length;
+    if (n < 2 || imag.length !== n || (n & (n - 1)) !== 0) {
+        throw new Error("FFT length must be a power of two");
+    }
+    for (let i = 1, j = 0; i < n; i += 1) {
+        let bit = n >> 1;
+        for (; (j & bit) !== 0; bit >>= 1)
+            j ^= bit;
+        j ^= bit;
+        if (i < j) {
+            const realSwap = real[i];
+            real[i] = real[j];
+            real[j] = realSwap;
+            const imagSwap = imag[i];
+            imag[i] = imag[j];
+            imag[j] = imagSwap;
+        }
+    }
+    for (let length = 2; length <= n; length <<= 1) {
+        const angle = (-2 * Math.PI) / length;
+        const stepReal = Math.cos(angle);
+        const stepImag = Math.sin(angle);
+        for (let start = 0; start < n; start += length) {
+            let twiddleReal = 1;
+            let twiddleImag = 0;
+            const half = length / 2;
+            for (let offset = 0; offset < half; offset += 1) {
+                const evenReal = real[start + offset];
+                const evenImag = imag[start + offset];
+                const oddIndex = start + offset + half;
+                const oddReal = real[oddIndex] * twiddleReal - imag[oddIndex] * twiddleImag;
+                const oddImag = real[oddIndex] * twiddleImag + imag[oddIndex] * twiddleReal;
+                real[start + offset] = evenReal + oddReal;
+                imag[start + offset] = evenImag + oddImag;
+                real[oddIndex] = evenReal - oddReal;
+                imag[oddIndex] = evenImag - oddImag;
+                const nextReal = twiddleReal * stepReal - twiddleImag * stepImag;
+                twiddleImag = twiddleReal * stepImag + twiddleImag * stepReal;
+                twiddleReal = nextReal;
+            }
+        }
+    }
+}

package/dist/rhythm/model.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+const beatSchema = z.object({ timeSeconds: z.number().finite().nonnegative(), confidence: z.number().min(0).max(1).nullable() });
+const musicEnergySchema = z.object({
+    algorithmId: z.string().min(1),
+    algorithmVersion: z.string().min(1),
+    hopSeconds: z.number().finite().positive(),
+    values: z.array(z.number().finite().min(0).max(1)).max(20000),
+});
+const sectionCandidateSchema = z.object({
+    id: z.string().min(1).max(100),
+    timeSeconds: z.number().finite().nonnegative().max(3600),
+    quality: z.number().min(0).max(1),
+});
+const sectionDetectionSchema = z.object({
+    algorithmId: z.string().min(1),
+    algorithmVersion: z.string().min(1),
+    candidates: z.array(sectionCandidateSchema).max(200),
+});
+export const musicAnalysisSchema = z.object({
+    analysisId: z.string(),
+    artifactId: z.string().uuid(),
+    objectHash: z.string(),
+    streamId: z.string().uuid(),
+    durationSeconds: z.number().finite().positive().max(3600),
+    analyzerVersion: z.string(),
+    beats: z.array(beatSchema).max(24000),
+    bpm: z.number().finite().positive().nullable(),
+    confidence: z.number().min(0).max(1).nullable(),
+    bars: z.array(beatSchema).max(24000).nullable(),
+    beatsPerBar: z.number().int().min(1).max(16).nullable(),
+    barSource: z.enum(["detected", "estimated"]).nullable().default(null),
+    waveform: z.array(z.number().finite().min(0).max(1)).max(65536),
+    lowConfidence: z.boolean(),
+    energy: musicEnergySchema.nullable().default(null),
+    sections: sectionDetectionSchema.nullable().default(null),
+});
+const SECTION_LABEL_VALUES = ["intro", "verse", "chorus", "drop", "break", "bridge", "outro"];
+export const sectionLabelsSchema = z.object({
+    schemaVersion: z.literal(1),
+    analysisId: z.string(),
+    artifactId: z.string().uuid(),
+    objectHash: z.string(),
+    streamId: z.string().uuid(),
+    labeler: z.object({ id: z.string(), version: z.string(), model: z.string() }),
+    boundaries: z.object({ algorithmId: z.string(), algorithmVersion: z.string() }),
+    status: z.enum(["ready", "unavailable"]),
+    reason: z.string().nullable().default(null),
+    createdAt: z.number().finite().positive(),
+    labels: z.array(z.object({
+        candidateId: z.string().min(1).max(100),
+        label: z.enum(SECTION_LABEL_VALUES),
+        confidence: z.number().min(0).max(1),
+        rationale: z.string().max(500),
+    })).max(200).default([]),
+});
+export const rhythmMarkerSchema = z.object({
+    id: z.string().min(1).max(100),
+    timeSeconds: z.number().finite().nonnegative().max(3600),
+    bar: z.boolean(),
+    manual: z.boolean(),
+});
+export const rhythmSettingsSchema = z.object({
+    masterClipId: z.string().uuid().nullable(),
+    correction: z.object({
+        objectHash: z.string(),
+        analysisId: z.string().nullable(),
+        markers: z.array(rhythmMarkerSchema).max(24000),
+        bpm: z.number().finite().min(20).max(400).nullable(),
+        beatsPerBar: z.number().int().min(1).max(16).nullable(),
+    }).nullable(),
+});