@elah/core 0.1.0

package/dist/export/ExportWorker.js

@@ -0,0 +1,371 @@
+import * as mb from 'mediabunny';
+import { trace, traceEnabled, enableChannels } from '../debug/trace';
+const t0 = performance.now();
+const STAGE_CHANNEL = {
+    worker: 'EXPORT',
+    run: 'EXPORT',
+    'assets:video': 'EXPORT_ASSETS',
+    'assets:image': 'EXPORT_ASSETS',
+    audio: 'EXPORT_AUDIO',
+    mediabunny: 'EXPORT_MUX',
+    frames: 'EXPORT_FRAMES',
+    'render:frame0': 'EXPORT_FRAMES',
+};
+function xlog(stage, msg, extra) {
+    const channel = STAGE_CHANNEL[stage] ?? 'EXPORT';
+    if (!traceEnabled(channel))
+        return;
+    const elapsed = ((performance.now() - t0) / 1000).toFixed(3);
+    const suffix = extra ? ' — ' + Object.entries(extra).map(([k, v]) => `${k}=${v}`).join(', ') : '';
+    trace(channel, `[${stage}] +${elapsed}s ${msg}${suffix}`);
+}
+async function timed(stage, label, fn) {
+    xlog(stage, `${label} ...`);
+    const start = performance.now();
+    const result = await fn();
+    xlog(stage, `${label} done`, { ms: (performance.now() - start).toFixed(1) });
+    return result;
+}
+function fmtBytes(n) {
+    if (n > 1000000)
+        return (n / 1000000).toFixed(2) + ' MB';
+    if (n > 1000)
+        return (n / 1000).toFixed(1) + ' KB';
+    return n + ' B';
+}
+import { resolveTimeline } from '../resolver/resolveTimeline';
+import { getTotalFrames } from '../utils/frames';
+import { resolveDrawRect } from '../renderer/gpu/layers/drawRect';
+import { computeTextLayout } from '../renderer/gpu/layers/textLayout';
+self.onmessage = async (e) => {
+    if (e.data?.type !== 'start')
+        return;
+    const { project, options, audio, trace: traceChannels } = e.data;
+    if (traceChannels)
+        enableChannels(traceChannels);
+    xlog('worker', 'message received — starting export');
+    try {
+        const buffer = await runExport(project, options, audio);
+        xlog('worker', 'posting buffer to main thread', { size: fmtBytes(buffer.byteLength) });
+        const msg = { type: 'done', buffer };
+        self.postMessage(msg, [buffer]);
+    }
+    catch (err) {
+        xlog('worker', `export failed: ${String(err)}`);
+        const msg = { type: 'error', message: String(err) };
+        self.postMessage(msg);
+    }
+};
+async function runExport(project, options, audio) {
+    const { width, height } = project.stage;
+    const fps = project.fps;
+    const totalFrames = getTotalFrames(project.clips);
+    xlog('run', 'starting', {
+        stage: `${width}x${height}`,
+        fps,
+        totalFrames,
+        durationSec: (totalFrames / fps).toFixed(2),
+        videoCodec: options.videoCodec ?? 'avc',
+        videoBitrate: options.videoBitrate ?? 8000000,
+        audioCodec: options.audioCodec ?? 'aac',
+        audioBitrate: options.audioBitrate ?? 128000,
+    });
+    if (totalFrames === 0)
+        throw new Error('ExportWorker: project has no clips');
+    const allClips = Object.values(project.clips).flat();
+    xlog('run', `clip inventory`, {
+        total: allClips.length,
+        video: allClips.filter(c => c.type === 'video').length,
+        image: allClips.filter(c => c.type === 'image').length,
+        audio: allClips.filter(c => c.type === 'audio').length,
+        text: allClips.filter(c => c.type === 'text').length,
+    });
+    const videoSrcs = [...new Set(allClips.filter(c => c.type === 'video' && c.src).map(c => c.src))];
+    xlog('assets:video', `opening ${videoSrcs.length} CanvasSink(s)`);
+    const videoSinks = new Map();
+    for (let i = 0; i < videoSrcs.length; i++) {
+        const src = videoSrcs[i];
+        xlog('assets:video', `[${i + 1}/${videoSrcs.length}] fetching "${src.slice(-40)}"`);
+        const fetchStart = performance.now();
+        const blob = await fetch(src).then(r => r.blob());
+        xlog('assets:video', `[${i + 1}/${videoSrcs.length}] fetched`, { size: fmtBytes(blob.size), ms: (performance.now() - fetchStart).toFixed(1) });
+        const input = new mb.Input({ formats: mb.ALL_FORMATS, source: new mb.BlobSource(blob) });
+        const track = await input.getPrimaryVideoTrack();
+        if (track) {
+            videoSinks.set(src, new mb.CanvasSink(track));
+            xlog('assets:video', `[${i + 1}/${videoSrcs.length}] CanvasSink ready`);
+        }
+        else {
+            xlog('assets:video', `[${i + 1}/${videoSrcs.length}] WARNING: no primary video track found`);
+        }
+    }
+    const imageSrcs = [...new Set(allClips.filter(c => c.type === 'image' && c.src).map(c => c.src))];
+    xlog('assets:image', `loading ${imageSrcs.length} ImageBitmap(s)`);
+    const imageBitmaps = new Map();
+    for (let i = 0; i < imageSrcs.length; i++) {
+        const src = imageSrcs[i];
+        xlog('assets:image', `[${i + 1}/${imageSrcs.length}] fetching "${src.slice(-40)}"`);
+        const fetchStart = performance.now();
+        const blob = await fetch(src).then(r => r.blob());
+        const bitmap = await createImageBitmap(blob);
+        imageBitmaps.set(src, bitmap);
+        xlog('assets:image', `[${i + 1}/${imageSrcs.length}] ready`, {
+            size: fmtBytes(blob.size),
+            bitmapW: bitmap.width,
+            bitmapH: bitmap.height,
+            ms: (performance.now() - fetchStart).toFixed(1),
+        });
+    }
+    if (audio) {
+        xlog('audio', `received mixed PCM`, {
+            channels: audio.numberOfChannels,
+            frames: audio.length,
+            sampleRate: audio.sampleRate,
+            durationSec: (audio.length / audio.sampleRate).toFixed(3),
+        });
+    }
+    else {
+        xlog('audio', 'no mixed audio received — exporting video-only');
+    }
+    xlog('mediabunny', `creating OffscreenCanvas ${width}x${height}`);
+    const outputCanvas = new OffscreenCanvas(width, height);
+    const ctx2d = outputCanvas.getContext('2d');
+    const videoCodec = options.videoCodec ?? 'avc';
+    const videoBitrate = options.videoBitrate ?? 8000000;
+    xlog('mediabunny', `creating CanvasSource`, { codec: videoCodec, bitrate: videoBitrate });
+    const canvasSource = new mb.CanvasSource(outputCanvas, {
+        codec: videoCodec,
+        bitrate: videoBitrate,
+    });
+    xlog('mediabunny', 'creating BufferTarget + Mp4Output');
+    const bufferTarget = new mb.BufferTarget();
+    const output = new mb.Output({ format: new mb.Mp4OutputFormat(), target: bufferTarget });
+    output.addVideoTrack(canvasSource);
+    xlog('mediabunny', 'video track added to output');
+    let audioSource = null;
+    if (audio) {
+        const audioCodec = options.audioCodec ?? 'aac';
+        const audioBitrate = options.audioBitrate ?? 128000;
+        xlog('mediabunny', `creating AudioSampleSource`, { codec: audioCodec, bitrate: audioBitrate });
+        audioSource = new mb.AudioSampleSource({
+            codec: audioCodec,
+            bitrate: audioBitrate,
+        });
+        output.addAudioTrack(audioSource);
+        xlog('mediabunny', 'audio track added to output');
+    }
+    await timed('mediabunny', 'output.start()', () => output.start());
+    if (audio && audioSource) {
+        await timed('mediabunny', 'audioSource.add() — encoding mixed PCM', () => addAudioMix(audioSource, audio));
+    }
+    xlog('frames', `starting frame loop`, { totalFrames, fps });
+    const loopStart = performance.now();
+    const logEvery = Math.max(1, Math.floor(totalFrames / 10));
+    let lastFrameTime = loopStart;
+    const transitionSnapshots = new Map();
+    for (let frame = 0; frame < totalFrames; frame++) {
+        if (frame === 0 || frame % logEvery === 0 || frame === totalFrames - 1) {
+            const now = performance.now();
+            const elapsed = now - loopStart;
+            const avgMsPerFrame = frame > 0 ? elapsed / frame : 0;
+            const pct = Math.round((frame / totalFrames) * 100);
+            xlog('frames', `frame ${frame}/${totalFrames} (${pct}%)`, {
+                avgMsPerFrame: avgMsPerFrame.toFixed(1),
+                sinceLastLog: (now - lastFrameTime).toFixed(1) + 'ms',
+            });
+            lastFrameTime = now;
+        }
+        const scene = resolveTimeline(frame, project);
+        for (const tr of scene.transitions) {
+            if (transitionSnapshots.has(tr.id))
+                continue;
+            const fromVideo = scene.videos.find(v => v.id === tr.fromClipId);
+            const fromImage = scene.images.find(i => i.id === tr.fromClipId);
+            if (fromVideo) {
+                const sink = videoSinks.get(fromVideo.src);
+                const sourceTimeSec = (fromVideo.sourceFrame + 0.5) / fps;
+                const wrapped = sink ? await sink.getCanvas(sourceTimeSec) : null;
+                if (wrapped) {
+                    const bmp = await createImageBitmap(wrapped.canvas);
+                    transitionSnapshots.set(tr.id, { source: bmp, owned: true });
+                }
+            }
+            else if (fromImage) {
+                const bmp = imageBitmaps.get(fromImage.src);
+                if (bmp)
+                    transitionSnapshots.set(tr.id, { source: bmp, owned: false });
+            }
+        }
+        await renderFrame(ctx2d, scene, videoSinks, imageBitmaps, transitionSnapshots, width, height, fps, frame);
+        await canvasSource.add(frame / fps, 1 / fps);
+        const activeIds = new Set(scene.transitions.map(tr => tr.id));
+        for (const [id, snap] of transitionSnapshots) {
+            if (!activeIds.has(id)) {
+                if (snap.owned)
+                    snap.source.close();
+                transitionSnapshots.delete(id);
+            }
+        }
+        const msg = { type: 'progress', frame, totalFrames };
+        self.postMessage(msg);
+    }
+    const loopMs = performance.now() - loopStart;
+    xlog('frames', `loop complete`, {
+        totalFrames,
+        totalMs: loopMs.toFixed(0),
+        avgMsPerFrame: (loopMs / totalFrames).toFixed(1),
+    });
+    await timed('mediabunny', 'output.finalize()', () => output.finalize());
+    if (!bufferTarget.buffer)
+        throw new Error('ExportWorker: buffer is null after finalize');
+    xlog('run', `export complete`, { outputSize: fmtBytes(bufferTarget.buffer.byteLength) });
+    return bufferTarget.buffer;
+}
+async function addAudioMix(source, audio) {
+    const { sampleRate, numberOfChannels, length } = audio;
+    const channels = audio.channels.map(b => new Float32Array(b));
+    const chunkFrames = sampleRate;
+    for (let start = 0; start < length; start += chunkFrames) {
+        const frames = Math.min(chunkFrames, length - start);
+        const data = new Float32Array(frames * numberOfChannels);
+        for (let c = 0; c < numberOfChannels; c++) {
+            data.set(channels[c].subarray(start, start + frames), c * frames);
+        }
+        const sample = new mb.AudioSample({
+            data,
+            format: 'f32-planar',
+            numberOfChannels,
+            sampleRate,
+            timestamp: start / sampleRate,
+        });
+        await source.add(sample);
+        sample.close();
+    }
+}
+async function renderFrame(ctx, scene, videoSinks, imageBitmaps, transitionSnapshots, stageW, stageH, fps, frameIndex) {
+    const isDebugFrame = frameIndex === 0;
+    if (isDebugFrame) {
+        xlog('render:frame0', `scene layers`, {
+            videos: scene.videos.length,
+            images: scene.images.length,
+            texts: scene.texts.length,
+        });
+    }
+    ctx.clearRect(0, 0, stageW, stageH);
+    ctx.fillStyle = '#000';
+    ctx.fillRect(0, 0, stageW, stageH);
+    const items = [
+        ...scene.videos.map(item => ({ kind: 'video', item })),
+        ...scene.images.map(item => ({ kind: 'image', item })),
+        ...scene.texts.map(item => ({ kind: 'text', item })),
+    ].sort((a, b) => a.item.zIndex - b.item.zIndex);
+    for (const entry of items) {
+        ctx.save();
+        ctx.globalAlpha = entry.item.opacity ?? 1;
+        if (entry.kind === 'video') {
+            const sink = videoSinks.get(entry.item.src);
+            if (sink) {
+                const sourceTimeSec = (entry.item.sourceFrame + 0.5) / fps;
+                if (isDebugFrame) {
+                    xlog('render:frame0', `video layer — seeking CanvasSink`, {
+                        src: entry.item.src.slice(-40),
+                        sourceTimeSec: sourceTimeSec.toFixed(4),
+                        zIndex: entry.item.zIndex,
+                        opacity: entry.item.opacity ?? 1,
+                    });
+                }
+                const seekStart = isDebugFrame ? performance.now() : 0;
+                const wrapped = await sink.getCanvas(sourceTimeSec);
+                if (isDebugFrame) {
+                    xlog('render:frame0', `video layer — getCanvas()`, {
+                        gotFrame: !!wrapped,
+                        ms: (performance.now() - seekStart).toFixed(1),
+                        ...(wrapped ? { canvasW: wrapped.canvas.width, canvasH: wrapped.canvas.height } : {}),
+                    });
+                }
+                if (wrapped) {
+                    drawMedia(ctx, wrapped.canvas, entry.item.transform, stageW, stageH);
+                }
+            }
+            else {
+                if (isDebugFrame)
+                    xlog('render:frame0', `video layer — WARNING: no CanvasSink for src "${entry.item.src.slice(-40)}"`);
+            }
+        }
+        else if (entry.kind === 'image') {
+            const bitmap = imageBitmaps.get(entry.item.src);
+            if (isDebugFrame) {
+                xlog('render:frame0', `image layer`, {
+                    src: entry.item.src.slice(-40),
+                    zIndex: entry.item.zIndex,
+                    hasBitmap: !!bitmap,
+                    ...(bitmap ? { bitmapW: bitmap.width, bitmapH: bitmap.height } : {}),
+                });
+            }
+            if (bitmap) {
+                drawMedia(ctx, bitmap, entry.item.transform, stageW, stageH);
+            }
+        }
+        else {
+            if (isDebugFrame) {
+                xlog('render:frame0', `text layer`, {
+                    content: entry.item.content?.slice(0, 30),
+                    zIndex: entry.item.zIndex,
+                    fontSize: entry.item.fontSize,
+                });
+            }
+            drawText(ctx, entry.item, stageW, stageH);
+        }
+        ctx.restore();
+    }
+    for (const tr of scene.transitions) {
+        const snap = transitionSnapshots.get(tr.id);
+        if (!snap)
+            continue;
+        ctx.save();
+        if (tr.kind === 'slide') {
+            const sign = tr.direction === 'left' ? -1 : 1;
+            ctx.translate(sign * tr.t * stageW, 0);
+            drawMedia(ctx, snap.source, undefined, stageW, stageH);
+        }
+        else if (tr.kind === 'wipe') {
+            ctx.beginPath();
+            ctx.rect(0, 0, stageW * (1 - tr.t), stageH);
+            ctx.clip();
+            drawMedia(ctx, snap.source, undefined, stageW, stageH);
+        }
+        else {
+            ctx.globalAlpha = 1 - tr.t;
+            drawMedia(ctx, snap.source, undefined, stageW, stageH);
+        }
+        ctx.restore();
+    }
+    if (isDebugFrame) {
+        xlog('render:frame0', `frame 0 draw complete — ${items.length} layer(s) composited onto ${stageW}x${stageH}`);
+    }
+}
+function drawMedia(ctx, source, transform, stageW, stageH) {
+    const rect = resolveDrawRect(transform, stageW, stageH, source.width, source.height);
+    const cx = rect.x + rect.width / 2;
+    const cy = rect.y + rect.height / 2;
+    ctx.translate(cx, cy);
+    ctx.rotate(rect.rotation);
+    ctx.drawImage(source, -rect.width / 2, -rect.height / 2, rect.width, rect.height);
+}
+function drawText(ctx, clip, stageW, stageH) {
+    const layout = computeTextLayout(ctx, clip, { width: stageW, height: stageH });
+    ctx.fillStyle = layout.style.color;
+    ctx.textAlign = layout.style.textAlign;
+    ctx.textBaseline = 'middle';
+    const rotation = clip.transform?.rotation ?? 0;
+    if (rotation !== 0) {
+        const cx = layout.center.x * stageW;
+        const cy = layout.center.y * stageH;
+        ctx.translate(cx, cy);
+        ctx.rotate(rotation);
+        ctx.translate(-cx, -cy);
+    }
+    for (let i = 0; i < layout.lines.length; i++) {
+        ctx.fillText(layout.lines[i], layout.anchorX, layout.firstLineY + i * layout.lineAdvance);
+    }
+}

package/dist/export/exportVideo.d.ts

@@ -0,0 +1,3 @@
+import type { Project } from '../types';
+import type { ExportOptions } from './types';
+export declare function exportVideo(project: Project, options?: ExportOptions): Promise<Blob>;

package/dist/export/exportVideo.js

@@ -0,0 +1,118 @@
+import { getTotalFrames } from '../utils/frames';
+import { trace, traceEnabled, getEnabledChannels } from '../debug/trace';
+function mlog(channel, msg) {
+    if (!traceEnabled(channel))
+        return;
+    trace(channel, `[main] ${msg}`);
+}
+async function renderAudioMix(project) {
+    const fps = project.fps;
+    const totalFrames = getTotalFrames(project.clips);
+    if (totalFrames === 0)
+        return null;
+    const allClips = Object.values(project.clips).flat();
+    const audioClips = allClips.filter(c => {
+        if (c.type !== 'audio' || !c.src || c.disabled)
+            return false;
+        const track = project.tracks.find(t => t.id === c.trackId);
+        return track && !track.muted && !track.disabled;
+    });
+    if (audioClips.length === 0) {
+        mlog('EXPORT_AUDIO', 'no active audio clips — exporting video-only');
+        return null;
+    }
+    const OAC = typeof OfflineAudioContext !== 'undefined'
+        ? OfflineAudioContext
+        : globalThis.webkitOfflineAudioContext;
+    if (!OAC) {
+        console.warn('[export:main] OfflineAudioContext unavailable — audio will be skipped');
+        return null;
+    }
+    const sampleRate = 44100;
+    const totalSec = totalFrames / fps;
+    mlog('EXPORT_AUDIO', `mixing ${audioClips.length} audio clip(s) — ${totalSec.toFixed(2)}s @ ${sampleRate}Hz`);
+    const ctx = new OAC(2, Math.ceil(sampleRate * totalSec), sampleRate);
+    for (const clip of audioClips) {
+        try {
+            const buf = await fetch(clip.src).then(r => r.arrayBuffer());
+            const decoded = await ctx.decodeAudioData(buf);
+            const node = ctx.createBufferSource();
+            node.buffer = decoded;
+            const gain = ctx.createGain();
+            gain.gain.value = clip.volume ?? 1;
+            node.connect(gain).connect(ctx.destination);
+            node.start(clip.startFrame / fps, clip.sourceStartFrame / fps, clip.durationFrames / fps);
+        }
+        catch (err) {
+            console.warn(`[export:main] audio clip "${clip.src?.slice(-40)}" skipped — decode error: ${String(err)}`);
+        }
+    }
+    const mixed = await ctx.startRendering();
+    const numberOfChannels = mixed.numberOfChannels;
+    const length = mixed.length;
+    const channels = [];
+    for (let c = 0; c < numberOfChannels; c++) {
+        channels.push(new Float32Array(mixed.getChannelData(c)).buffer);
+    }
+    mlog('EXPORT_AUDIO', `audio mix ready — channels=${numberOfChannels} frames=${length}`);
+    return { sampleRate, numberOfChannels, length, channels };
+}
+export async function exportVideo(project, options = {}) {
+    const t0 = performance.now();
+    const totalClips = Object.values(project.clips).flat().length;
+    mlog('EXPORT', `exportVideo() called — stage=${project.stage.width}x${project.stage.height} fps=${project.fps} clips=${totalClips}`);
+    const audio = await renderAudioMix(project);
+    const { signal } = options;
+    if (signal?.aborted)
+        return Promise.reject(signal.reason ?? new DOMException('Export aborted', 'AbortError'));
+    return new Promise((resolve, reject) => {
+        mlog('EXPORT', 'spawning ExportWorker (module worker)');
+        const worker = new Worker(new URL('./ExportWorker.ts', import.meta.url), { type: 'module' });
+        const abort = () => {
+            worker.terminate();
+            mlog('EXPORT', 'aborted by signal');
+            reject(signal?.reason ?? new DOMException('Export aborted', 'AbortError'));
+        };
+        signal?.addEventListener('abort', abort, { once: true });
+        let lastLoggedPct = -1;
+        worker.onmessage = (e) => {
+            const msg = e.data;
+            if (msg.type === 'progress') {
+                options.onProgress?.({ frame: msg.frame, totalFrames: msg.totalFrames });
+                const pct = Math.round((msg.frame / msg.totalFrames) * 100);
+                if (pct !== lastLoggedPct && pct % 10 === 0) {
+                    lastLoggedPct = pct;
+                    mlog('EXPORT_FRAMES', `progress ${pct}% (frame ${msg.frame}/${msg.totalFrames})`);
+                }
+            }
+            else if (msg.type === 'done') {
+                signal?.removeEventListener('abort', abort);
+                worker.terminate();
+                const elapsed = ((performance.now() - t0) / 1000).toFixed(2);
+                const blob = new Blob([msg.buffer], { type: 'video/mp4' });
+                mlog('EXPORT', `done — blob=${(blob.size / 1000000).toFixed(2)}MB totalTime=${elapsed}s`);
+                resolve(blob);
+            }
+            else if (msg.type === 'error') {
+                signal?.removeEventListener('abort', abort);
+                worker.terminate();
+                console.error(`[export:main] worker reported error: ${msg.message}`);
+                reject(new Error(msg.message));
+            }
+        };
+        worker.onerror = (e) => {
+            signal?.removeEventListener('abort', abort);
+            worker.terminate();
+            console.error(`[export:main] worker crashed: ${e.message}`);
+            reject(new Error(`ExportWorker crashed: ${e.message}`));
+        };
+        mlog('EXPORT', 'posting start message to worker');
+        worker.postMessage({
+            type: 'start',
+            project,
+            options: { ...options, onProgress: undefined, signal: undefined },
+            audio,
+            trace: getEnabledChannels(),
+        }, audio ? audio.channels : []);
+    });
+}

package/dist/export/index.d.ts

@@ -0,0 +1,2 @@
+export { exportVideo } from './exportVideo';
+export type { ExportOptions, ExportProgress, ExportVideoCodec, ExportAudioCodec } from './types';

package/dist/export/index.js

@@ -0,0 +1 @@
+export { exportVideo } from './exportVideo';

package/dist/export/lazyExport.d.ts

@@ -0,0 +1,4 @@
+import type { Project } from '../types';
+import type { ExportOptions } from './types';
+export declare function lazyExportVideo(project: Project, options?: ExportOptions): Promise<Blob>;
+export type { ExportOptions, ExportProgress, ExportVideoCodec, ExportAudioCodec } from './types';

package/dist/export/lazyExport.js

@@ -0,0 +1,4 @@
+export async function lazyExportVideo(project, options) {
+    const { exportVideo: actualExport } = await import('./exportVideo');
+    return actualExport(project, options);
+}

package/dist/export/types.d.ts

@@ -0,0 +1,37 @@
+export type ExportVideoCodec = 'avc' | 'vp9' | 'vp8';
+export type ExportAudioCodec = 'aac' | 'opus';
+export interface ExportOptions {
+    videoCodec?: ExportVideoCodec;
+    audioCodec?: ExportAudioCodec;
+    videoBitrate?: number;
+    audioBitrate?: number;
+    onProgress?: (progress: ExportProgress) => void;
+    signal?: AbortSignal;
+}
+export interface ExportProgress {
+    frame: number;
+    totalFrames: number;
+}
+export interface RenderedAudio {
+    sampleRate: number;
+    numberOfChannels: number;
+    length: number;
+    channels: ArrayBuffer[];
+}
+export type WorkerInMessage = {
+    type: 'start';
+    project: unknown;
+    options: ExportOptions;
+    audio: RenderedAudio | null;
+};
+export type WorkerOutMessage = {
+    type: 'progress';
+    frame: number;
+    totalFrames: number;
+} | {
+    type: 'done';
+    buffer: ArrayBuffer;
+} | {
+    type: 'error';
+    message: string;
+};

package/dist/export/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+export type { Clip, Track, Project, Transform, TextAnimation, TextAnimationKind, ClipType, TrackKind, FrameCount, TimelineConfig, InitialTrackConfig, EngineEvent, Transition, TransitionKind, TransitionEasing, TransitionDirection, } from './types';
+export { TimelineEngine } from './editor/TimelineEngine';
+export { PlaybackEngine } from './playback/PlaybackEngine';
+export type { PlaybackSnapshot, PlaybackEngineConfig } from './playback/PlaybackEngine';
+export { resolveTimeline } from './resolver/resolveTimeline';
+export type { Scene, ActiveTransition, ActiveVideoClip, ActiveAudioClip, ActiveTextClip, ActiveImageClip, ActiveClipBase, } from './resolver/scene';
+export type { Renderer } from './renderer/types';
+export { GpuRenderer } from './renderer/gpu/GpuRenderer';
+export type { RendererOptions } from './renderer/gpu/types';
+export { resolveDrawRect, transformFromContainRect } from './renderer/gpu/layers/drawRect';
+export { computeContainViewport } from './renderer/gpu/viewport';
+export { computeTextLayout, SIDE_MARGIN } from './renderer/gpu/layers/textLayout';
+export type { TextLayout } from './renderer/gpu/layers/textLayout';
+export type { DemuxerBackend as MediabunnyDemuxer } from './media/video/demuxer/MediabunnyDemuxer';
+export { GpuDebugCounters } from './renderer/gpu/debug/GpuDebugCounters';
+export type { CounterSnapshot } from './renderer/gpu/debug/GpuDebugCounters';
+export { createMediabunnyBackend, isMediabunnyCompatible } from './media/video/demuxer/createMediabunnyBackend';
+export type { MediabunnyModule, CreateMediabunnyBackendOpts } from './media/video/demuxer/createMediabunnyBackend';
+export type { DemuxerBackend, DemuxerFactory } from './media/video/demuxer/MediabunnyDemuxer';
+export type { VideoFrameProvider, VideoFrameProviderDeps } from './media/video';
+export { createVideoFrameProvider, MockVideoFrameProvider, SyntheticVideoFrameProvider } from './media/video';
+export { AudioPlaybackController } from './media/audio/AudioPlaybackController';
+export type { AudioPlaybackControllerOptions } from './media/audio/AudioPlaybackController';
+export { useMediaLibrary, useMediaLibraryStore, MEDIA_DRAG_MIME, importFiles } from './assets';
+export type { MediaAsset, MediaKind, DragMediaPayload, ImportFilesOptions, ImportFilesResult, SkippedImport } from './assets';
+export { useTracksStore } from './stores/tracks.store';
+export type { TracksState, TracksActions } from './stores/tracks.store';
+export { usePlaybackStore } from './stores/playback.store';
+export type { PlaybackState, PlaybackActions } from './stores/playback.store';
+export { useSelectionStore } from './stores/selection.store';
+export type { SelectionState, SelectionActions } from './stores/selection.store';
+export { useTransitionsStore } from './stores/transitions.store';
+export type { CreateClipOptions } from './elements/base';
+export { createVideoClip } from './elements/video';
+export { createAudioClip } from './elements/audio';
+export { createTextClip } from './elements/text';
+export { createImageClip } from './elements/image';
+export { splitClipAtPlayhead } from './actions/splitClipAtPlayhead';
+export type { SplitAtPlayheadData } from './actions/splitClipAtPlayhead';
+export type { ActionResult, ActionFailureReason } from './actions/types';
+export { framesToTimecode, secondsToFrames, framesToSeconds, getTotalFrames, clipsOverlap } from './utils/frames';
+export { generateId } from './utils/id';
+export { snapFrame, buildSnapPoints, resolveOverlapEdgeSnap, DEFAULT_OVERLAP_TOLERANCE } from './utils/snap';
+export { exportVideo } from './export';
+export { lazyExportVideo } from './export/lazyExport';
+export type { ExportOptions, ExportProgress, ExportVideoCodec, ExportAudioCodec } from './export';
+export { useEditor, useTimelineEngine, usePlaybackEngine, EditorContext, } from './editor-context';
+export { installTraceGlobal, trace } from './debug/trace';

package/dist/index.js

@@ -0,0 +1,28 @@
+export { TimelineEngine } from './editor/TimelineEngine';
+export { PlaybackEngine } from './playback/PlaybackEngine';
+export { resolveTimeline } from './resolver/resolveTimeline';
+export { GpuRenderer } from './renderer/gpu/GpuRenderer';
+export { resolveDrawRect, transformFromContainRect } from './renderer/gpu/layers/drawRect';
+export { computeContainViewport } from './renderer/gpu/viewport';
+export { computeTextLayout, SIDE_MARGIN } from './renderer/gpu/layers/textLayout';
+export { GpuDebugCounters } from './renderer/gpu/debug/GpuDebugCounters';
+export { createMediabunnyBackend, isMediabunnyCompatible } from './media/video/demuxer/createMediabunnyBackend';
+export { createVideoFrameProvider, MockVideoFrameProvider, SyntheticVideoFrameProvider } from './media/video';
+export { AudioPlaybackController } from './media/audio/AudioPlaybackController';
+export { useMediaLibrary, useMediaLibraryStore, MEDIA_DRAG_MIME, importFiles } from './assets';
+export { useTracksStore } from './stores/tracks.store';
+export { usePlaybackStore } from './stores/playback.store';
+export { useSelectionStore } from './stores/selection.store';
+export { useTransitionsStore } from './stores/transitions.store';
+export { createVideoClip } from './elements/video';
+export { createAudioClip } from './elements/audio';
+export { createTextClip } from './elements/text';
+export { createImageClip } from './elements/image';
+export { splitClipAtPlayhead } from './actions/splitClipAtPlayhead';
+export { framesToTimecode, secondsToFrames, framesToSeconds, getTotalFrames, clipsOverlap } from './utils/frames';
+export { generateId } from './utils/id';
+export { snapFrame, buildSnapPoints, resolveOverlapEdgeSnap, DEFAULT_OVERLAP_TOLERANCE } from './utils/snap';
+export { exportVideo } from './export';
+export { lazyExportVideo } from './export/lazyExport';
+export { useEditor, useTimelineEngine, usePlaybackEngine, EditorContext, } from './editor-context';
+export { installTraceGlobal, trace } from './debug/trace';

package/dist/media/audio/AudioPlaybackController.d.ts

@@ -0,0 +1,26 @@
+import type { PlaybackEngine } from '../../playback/PlaybackEngine';
+import type { Project } from '../../types';
+export interface AudioPlaybackControllerOptions {
+    audioContextFactory?: () => AudioContext;
+}
+export declare class AudioPlaybackController {
+    private readonly _playback;
+    private readonly _getProject;
+    private readonly _audioContextFactory;
+    private _ctx;
+    private readonly _buffers;
+    private _node;
+    private _gain;
+    private _activeClipId;
+    private _lastEpoch;
+    private _scheduleToken;
+    private _unsub;
+    constructor(playback: PlaybackEngine, getProject: () => Project, options?: AudioPlaybackControllerOptions);
+    start(): void;
+    destroy(): void;
+    private _onSnapshot;
+    private _schedule;
+    private _startNode;
+    private _stop;
+    private _ensureBuffer;
+}