@elah/core 0.1.0

package/dist/actions/index.d.ts

@@ -0,0 +1,3 @@
+export { splitClipAtPlayhead } from './splitClipAtPlayhead';
+export type { SplitAtPlayheadData } from './splitClipAtPlayhead';
+export type { ActionResult, ActionFailureReason } from './types';

package/dist/actions/index.js

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

package/dist/actions/splitClipAtPlayhead.d.ts

@@ -0,0 +1,8 @@
+import type { TimelineEngine } from '../editor/TimelineEngine';
+import type { ActionResult } from './types';
+export interface SplitAtPlayheadData {
+    leftId: string;
+    rightId: string;
+    trackId: string;
+}
+export declare function splitClipAtPlayhead(engine: TimelineEngine): ActionResult<SplitAtPlayheadData>;

package/dist/actions/splitClipAtPlayhead.js

@@ -0,0 +1,34 @@
+import { useSelectionStore } from '../stores/selection.store';
+import { usePlaybackStore } from '../stores/playback.store';
+export function splitClipAtPlayhead(engine) {
+    const selectedIds = useSelectionStore.getState().selectedClipIds;
+    const isPlaying = usePlaybackStore.getState().isPlaying;
+    if (isPlaying)
+        return { ok: false, reason: 'cannot-split-while-playing' };
+    if (selectedIds.size === 0)
+        return { ok: false, reason: 'no-selection' };
+    if (selectedIds.size > 1)
+        return { ok: false, reason: 'multi-selection' };
+    const [clipId] = selectedIds;
+    if (!clipId)
+        return { ok: false, reason: 'no-selection' };
+    const found = engine.findClip(clipId);
+    if (!found)
+        return { ok: false, reason: 'clip-not-found' };
+    const { clip, trackId } = found;
+    const frame = usePlaybackStore.getState().currentFrame;
+    if (frame <= clip.startFrame ||
+        frame >= clip.startFrame + clip.durationFrames) {
+        return { ok: false, reason: 'playhead-outside-clip' };
+    }
+    let result = null;
+    engine.batch(() => {
+        result = engine.splitClip(clip.id, trackId, frame);
+    }, 'Split at playhead');
+    if (!result)
+        return { ok: false, reason: 'engine-rejected' };
+    return {
+        ok: true,
+        data: { leftId: result[0], rightId: result[1], trackId },
+    };
+}

package/dist/actions/types.d.ts

@@ -0,0 +1,8 @@
+export type ActionResult<T = void> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    reason: ActionFailureReason;
+};
+export type ActionFailureReason = 'no-selection' | 'multi-selection' | 'clip-not-found' | 'playhead-outside-clip' | 'engine-rejected' | 'cannot-split-while-playing';

package/dist/actions/types.js

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

package/dist/assets/importFiles.d.ts

@@ -0,0 +1,29 @@
+import type { MediaAsset } from './types';
+export interface ImportFilesOptions {
+    fallbackFps?: number;
+    thumbnailMaxDim?: number;
+}
+export interface SkippedImport {
+    file: File;
+    reason: 'duplicate' | 'unsupported';
+    existingAssetId?: string;
+}
+export interface ImportFilesResult {
+    imported: MediaAsset[];
+    skipped: SkippedImport[];
+}
+interface ProbedMetadata {
+    durationSec: number;
+    width?: number;
+    height?: number;
+    hasAudio?: boolean;
+}
+export declare function probeVideo(src: string): Promise<ProbedMetadata>;
+export declare function probeAudio(src: string): Promise<ProbedMetadata>;
+export declare function probeImage(src: string): Promise<ProbedMetadata>;
+export declare function makeVideoThumbnail(src: string, maxDim: number): Promise<string>;
+export declare function makeVideoThumbnailStrip(src: string, count: number, maxDim: number): Promise<string[]>;
+export declare function makeImageThumbnail(src: string, maxDim: number): Promise<string>;
+export declare function computeWaveform(src: string): Promise<Float32Array | null>;
+export declare function importFiles(files: File[], opts?: ImportFilesOptions): Promise<ImportFilesResult>;
+export {};

package/dist/assets/importFiles.js

@@ -0,0 +1,351 @@
+import { generateId } from '../utils/id';
+import { useMediaLibraryStore } from './store';
+const DEFAULT_THUMBNAIL_MAX_DIM = 240;
+const THUMBNAIL_STRIP_COUNT = 4;
+const THUMBNAIL_STRIP_MAX_DIM = 160;
+const WAVEFORM_PEAK_COUNT = 256;
+function detectHasAudio(el) {
+    const probe = el;
+    if (probe.audioTracks)
+        return probe.audioTracks.length > 0;
+    if (typeof probe.mozHasAudio === 'boolean')
+        return probe.mozHasAudio;
+    if (typeof probe.webkitAudioDecodedByteCount === 'number') {
+        return probe.webkitAudioDecodedByteCount > 0;
+    }
+    return false;
+}
+function dedupeKey(file) {
+    return `${file.name}|${file.size}|${file.lastModified}`;
+}
+function inferKind(mimeType) {
+    if (mimeType.startsWith('video/'))
+        return 'video';
+    if (mimeType.startsWith('audio/'))
+        return 'audio';
+    if (mimeType.startsWith('image/'))
+        return 'image';
+    return null;
+}
+function loadMediaElement(tag, src, onReady) {
+    return new Promise((resolve, reject) => {
+        const el = document.createElement(tag);
+        el.preload = 'metadata';
+        el.muted = true;
+        const cleanup = () => {
+            el.removeEventListener('loadedmetadata', onLoaded);
+            el.removeEventListener('error', onError);
+        };
+        const onLoaded = () => {
+            cleanup();
+            onReady(el);
+            resolve(el);
+        };
+        const onError = () => {
+            cleanup();
+            reject(new Error(`Failed to load ${tag} metadata`));
+        };
+        el.addEventListener('loadedmetadata', onLoaded);
+        el.addEventListener('error', onError);
+        el.src = src;
+    });
+}
+export async function probeVideo(src) {
+    const el = await loadMediaElement('video', src, () => { });
+    return {
+        durationSec: el.duration,
+        width: el.videoWidth,
+        height: el.videoHeight,
+        hasAudio: detectHasAudio(el),
+    };
+}
+export async function probeAudio(src) {
+    const el = await loadMediaElement('audio', src, () => { });
+    return {
+        durationSec: el.duration,
+    };
+}
+export async function probeImage(src) {
+    return new Promise((resolve, reject) => {
+        const img = document.createElement('img');
+        const cleanup = () => {
+            img.onload = null;
+            img.onerror = null;
+        };
+        img.onload = () => {
+            cleanup();
+            resolve({
+                durationSec: 0,
+                width: img.naturalWidth,
+                height: img.naturalHeight,
+            });
+        };
+        img.onerror = () => {
+            cleanup();
+            reject(new Error('Failed to load image metadata'));
+        };
+        img.src = src;
+    });
+}
+async function probeMetadata(kind, src) {
+    switch (kind) {
+        case 'video':
+            return probeVideo(src);
+        case 'audio':
+            return probeAudio(src);
+        case 'image':
+            return probeImage(src);
+    }
+}
+function scaleToFit(width, height, maxDim) {
+    if (width <= maxDim && height <= maxDim) {
+        return { width, height };
+    }
+    const scale = maxDim / Math.max(width, height);
+    return {
+        width: Math.round(width * scale),
+        height: Math.round(height * scale),
+    };
+}
+function drawToThumbnail(source, sourceWidth, sourceHeight, maxDim) {
+    const { width, height } = scaleToFit(sourceWidth, sourceHeight, maxDim);
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to acquire 2D canvas context');
+    }
+    ctx.drawImage(source, 0, 0, width, height);
+    return canvas.toDataURL('image/jpeg', 0.7);
+}
+export async function makeVideoThumbnail(src, maxDim) {
+    const el = await loadMediaElement('video', src, (video) => {
+        video.currentTime = 0;
+    });
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            el.removeEventListener('seeked', onSeeked);
+            el.removeEventListener('error', onError);
+        };
+        const onSeeked = () => {
+            cleanup();
+            try {
+                resolve(drawToThumbnail(el, el.videoWidth, el.videoHeight, maxDim));
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        const onError = () => {
+            cleanup();
+            reject(new Error('Failed to seek video for thumbnail'));
+        };
+        if (el.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+            onSeeked();
+            return;
+        }
+        el.addEventListener('seeked', onSeeked);
+        el.addEventListener('error', onError);
+    });
+}
+export async function makeVideoThumbnailStrip(src, count, maxDim) {
+    const el = await loadMediaElement('video', src, () => { });
+    const duration = Number.isFinite(el.duration) ? el.duration : 0;
+    const seekTo = (time) => new Promise((resolve, reject) => {
+        const cleanup = () => {
+            el.removeEventListener('seeked', onSeeked);
+            el.removeEventListener('error', onError);
+        };
+        const onSeeked = () => {
+            cleanup();
+            try {
+                resolve(drawToThumbnail(el, el.videoWidth, el.videoHeight, maxDim));
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        const onError = () => {
+            cleanup();
+            reject(new Error('Failed to seek video for thumbnail strip'));
+        };
+        el.addEventListener('seeked', onSeeked);
+        el.addEventListener('error', onError);
+        el.currentTime = time;
+    });
+    const frames = [];
+    for (let i = 0; i < count; i++) {
+        const time = duration > 0 ? ((i + 0.5) / count) * duration : 0;
+        frames.push(await seekTo(time));
+    }
+    return frames;
+}
+export async function makeImageThumbnail(src, maxDim) {
+    return new Promise((resolve, reject) => {
+        const img = document.createElement('img');
+        const cleanup = () => {
+            img.onload = null;
+            img.onerror = null;
+        };
+        img.onload = () => {
+            cleanup();
+            try {
+                resolve(drawToThumbnail(img, img.naturalWidth, img.naturalHeight, maxDim));
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        img.onerror = () => {
+            cleanup();
+            reject(new Error('Failed to load image for thumbnail'));
+        };
+        img.src = src;
+    });
+}
+let sharedAudioContext = null;
+function getAudioContext() {
+    if (!sharedAudioContext) {
+        const Ctor = window.AudioContext ??
+            window
+                .webkitAudioContext;
+        sharedAudioContext = new Ctor();
+    }
+    return sharedAudioContext;
+}
+export async function computeWaveform(src) {
+    const res = await fetch(src);
+    const buffer = await res.arrayBuffer();
+    const audioBuffer = await getAudioContext().decodeAudioData(buffer);
+    if (audioBuffer.length === 0)
+        return null;
+    const channel = audioBuffer.getChannelData(0);
+    const peaks = new Float32Array(WAVEFORM_PEAK_COUNT);
+    const bucketSize = Math.max(1, Math.floor(channel.length / WAVEFORM_PEAK_COUNT));
+    let globalMax = 0;
+    for (let i = 0; i < WAVEFORM_PEAK_COUNT; i++) {
+        const start = i * bucketSize;
+        const end = Math.min(start + bucketSize, channel.length);
+        let max = 0;
+        for (let j = start; j < end; j++) {
+            const v = Math.abs(channel[j]);
+            if (v > max)
+                max = v;
+        }
+        peaks[i] = max;
+        if (max > globalMax)
+            globalMax = max;
+    }
+    if (globalMax > 0) {
+        for (let i = 0; i < peaks.length; i++)
+            peaks[i] /= globalMax;
+    }
+    return peaks;
+}
+function scheduleThumbnail(asset, maxDim) {
+    if (asset.kind === 'video') {
+        void makeVideoThumbnailStrip(asset.src, THUMBNAIL_STRIP_COUNT, THUMBNAIL_STRIP_MAX_DIM)
+            .then((strip) => {
+            if (strip.length === 0)
+                return;
+            useMediaLibraryStore.getState().updateAsset(asset.id, {
+                thumbnailStrip: strip,
+                thumbnailUrl: strip[Math.floor(strip.length / 2)],
+            });
+        })
+            .catch((err) => {
+            console.warn(`[importFiles] Thumbnail strip failed for "${asset.name}":`, err);
+        });
+        return;
+    }
+    if (asset.kind === 'image') {
+        void makeImageThumbnail(asset.src, maxDim)
+            .then((thumbnailUrl) => {
+            useMediaLibraryStore.getState().updateAsset(asset.id, { thumbnailUrl });
+        })
+            .catch((err) => {
+            console.warn(`[importFiles] Thumbnail failed for "${asset.name}":`, err);
+        });
+    }
+}
+function scheduleAudioAnalysis(asset) {
+    if (asset.kind !== 'audio' && asset.kind !== 'video')
+        return;
+    void computeWaveform(asset.src)
+        .then((waveform) => {
+        if (!waveform) {
+            if (asset.kind === 'video') {
+                useMediaLibraryStore.getState().updateAsset(asset.id, { hasAudio: false });
+            }
+            return;
+        }
+        useMediaLibraryStore.getState().updateAsset(asset.id, {
+            waveform,
+            ...(asset.kind === 'video' ? { hasAudio: true } : {}),
+        });
+    })
+        .catch(() => {
+        if (asset.kind === 'video') {
+            useMediaLibraryStore.getState().updateAsset(asset.id, { hasAudio: false });
+        }
+    });
+}
+async function importSingleFile(file, kind, thumbnailMaxDim) {
+    const src = URL.createObjectURL(file);
+    const metadata = await probeMetadata(kind, src);
+    const asset = {
+        id: generateId(),
+        kind,
+        name: file.name,
+        src,
+        durationSec: metadata.durationSec,
+        width: metadata.width,
+        height: metadata.height,
+        ...(kind === 'video' ? { hasAudio: metadata.hasAudio ?? false } : {}),
+        byteSize: file.size,
+        lastModified: file.lastModified,
+        addedAt: Date.now(),
+    };
+    useMediaLibraryStore.getState().addAsset(asset);
+    scheduleThumbnail(asset, thumbnailMaxDim);
+    scheduleAudioAnalysis(asset);
+    return asset;
+}
+function partitionFiles(files) {
+    const storeAssets = useMediaLibraryStore.getState().assets;
+    const existingByKey = new Map();
+    for (const asset of Object.values(storeAssets)) {
+        existingByKey.set(dedupeKey({ name: asset.name, size: asset.byteSize, lastModified: asset.lastModified }), asset.id);
+    }
+    const batchKeys = new Set();
+    const toImport = [];
+    const skipped = [];
+    for (const file of files) {
+        const kind = inferKind(file.type);
+        if (!kind) {
+            console.warn(`[importFiles] Skipping unsupported file type: "${file.type}" (${file.name})`);
+            skipped.push({ file, reason: 'unsupported' });
+            continue;
+        }
+        const key = dedupeKey(file);
+        const existingAssetId = existingByKey.get(key);
+        if (existingAssetId) {
+            skipped.push({ file, reason: 'duplicate', existingAssetId });
+            continue;
+        }
+        if (batchKeys.has(key)) {
+            skipped.push({ file, reason: 'duplicate' });
+            continue;
+        }
+        batchKeys.add(key);
+        toImport.push({ file, kind });
+    }
+    return { toImport, skipped };
+}
+export async function importFiles(files, opts) {
+    const thumbnailMaxDim = opts?.thumbnailMaxDim ?? DEFAULT_THUMBNAIL_MAX_DIM;
+    const { toImport, skipped } = partitionFiles(files);
+    const imported = await Promise.all(toImport.map(({ file, kind }) => importSingleFile(file, kind, thumbnailMaxDim)));
+    return { imported, skipped };
+}

package/dist/assets/index.d.ts

@@ -0,0 +1,10 @@
+import type { MediaAsset } from './types';
+export type { MediaAsset, MediaKind, DragMediaPayload } from './types';
+export { MEDIA_DRAG_MIME } from './types';
+export { useMediaLibraryStore } from './store';
+export { importFiles } from './importFiles';
+export type { ImportFilesOptions, ImportFilesResult, SkippedImport } from './importFiles';
+export declare function useMediaLibrary(): {
+    assets: MediaAsset[];
+    getAsset: (id: string) => MediaAsset | undefined;
+};

package/dist/assets/index.js

@@ -0,0 +1,13 @@
+import { useMediaLibraryStore } from './store';
+export { MEDIA_DRAG_MIME } from './types';
+export { useMediaLibraryStore } from './store';
+export { importFiles } from './importFiles';
+export function useMediaLibrary() {
+    const order = useMediaLibraryStore((s) => s.order);
+    const assets = useMediaLibraryStore((s) => s.assets);
+    const getAsset = useMediaLibraryStore((s) => s.getAsset);
+    return {
+        assets: order.map((id) => assets[id]).filter(Boolean),
+        getAsset,
+    };
+}

package/dist/assets/store.d.ts

@@ -0,0 +1,13 @@
+import type { MediaAsset } from './types';
+interface MediaLibraryState {
+    assets: Record<string, MediaAsset>;
+    order: string[];
+}
+interface MediaLibraryActions {
+    addAsset: (asset: MediaAsset) => void;
+    removeAsset: (id: string) => void;
+    updateAsset: (id: string, patch: Partial<MediaAsset>) => void;
+    getAsset: (id: string) => MediaAsset | undefined;
+}
+export declare const useMediaLibraryStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MediaLibraryState & MediaLibraryActions>>;
+export {};

package/dist/assets/store.js

@@ -0,0 +1,20 @@
+import { create } from 'zustand';
+export const useMediaLibraryStore = create((set, get) => ({
+    assets: {},
+    order: [],
+    addAsset: (asset) => set((s) => ({
+        assets: { ...s.assets, [asset.id]: asset },
+        order: s.order.includes(asset.id) ? s.order : [...s.order, asset.id],
+    })),
+    removeAsset: (id) => set((s) => {
+        const { [id]: _removed, ...rest } = s.assets;
+        return { assets: rest, order: s.order.filter((x) => x !== id) };
+    }),
+    updateAsset: (id, patch) => set((s) => {
+        const existing = s.assets[id];
+        if (!existing)
+            return s;
+        return { assets: { ...s.assets, [id]: { ...existing, ...patch } } };
+    }),
+    getAsset: (id) => get().assets[id],
+}));

package/dist/assets/types.d.ts

@@ -0,0 +1,23 @@
+export type MediaKind = 'video' | 'audio' | 'image';
+export interface MediaAsset {
+    id: string;
+    kind: MediaKind;
+    name: string;
+    src: string;
+    durationSec: number;
+    width?: number;
+    height?: number;
+    sourceFps?: number;
+    hasAudio?: boolean;
+    thumbnailUrl?: string;
+    thumbnailStrip?: string[];
+    waveform?: Float32Array;
+    byteSize: number;
+    lastModified: number;
+    addedAt: number;
+}
+export declare const MEDIA_DRAG_MIME = "application/x-elah-media";
+export interface DragMediaPayload {
+    kind: 'media-asset';
+    assetId: string;
+}

package/dist/assets/types.js

@@ -0,0 +1 @@
+export const MEDIA_DRAG_MIME = 'application/x-elah-media';

package/dist/debug/trace.d.ts

@@ -0,0 +1,20 @@
+export type TraceChannel = 'SET_PLAYHEAD' | 'PLAYHEAD' | 'SEEK_GATE' | 'FEED' | 'DECODE' | 'CACHE_PUT' | 'CACHE_GET' | 'UPLOAD' | 'DRAW' | 'EXPORT' | 'EXPORT_ASSETS' | 'EXPORT_AUDIO' | 'EXPORT_MUX' | 'EXPORT_FRAMES';
+export declare function trace(channel: TraceChannel, ...args: unknown[]): void;
+export declare function traceEnabled(channel: TraceChannel): boolean;
+export declare function getEnabledChannels(): TraceChannel[];
+export declare function enableChannels(channels: TraceChannel[]): void;
+interface TraceConsoleApi {
+    on(...channels: TraceChannel[]): TraceChannel[];
+    off(...channels: TraceChannel[]): TraceChannel[];
+    all(): TraceChannel[];
+    none(): TraceChannel[];
+    status(): TraceChannel[];
+    channels: TraceChannel[];
+}
+declare global {
+    interface Window {
+        __trace?: TraceConsoleApi;
+    }
+}
+export declare function installTraceGlobal(): void;
+export {};

package/dist/debug/trace.js

@@ -0,0 +1,98 @@
+const ALL_CHANNELS = [
+    'SET_PLAYHEAD',
+    'PLAYHEAD',
+    'SEEK_GATE',
+    'FEED',
+    'DECODE',
+    'CACHE_PUT',
+    'CACHE_GET',
+    'UPLOAD',
+    'DRAW',
+    'EXPORT',
+    'EXPORT_ASSETS',
+    'EXPORT_AUDIO',
+    'EXPORT_MUX',
+    'EXPORT_FRAMES',
+];
+const STORAGE_KEY = 'myeditor-trace-channels';
+const enabled = new Set();
+function persist() {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify([...enabled]));
+    }
+    catch {
+    }
+}
+function restore() {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return;
+        for (const ch of JSON.parse(raw)) {
+            if (ALL_CHANNELS.includes(ch))
+                enabled.add(ch);
+        }
+    }
+    catch {
+    }
+}
+export function trace(channel, ...args) {
+    if (!enabled.has(channel))
+        return;
+    console.log(`[${channel}]`, ...args);
+}
+export function traceEnabled(channel) {
+    return enabled.has(channel);
+}
+export function getEnabledChannels() {
+    return [...enabled];
+}
+export function enableChannels(channels) {
+    for (const ch of channels) {
+        if (ALL_CHANNELS.includes(ch))
+            enabled.add(ch);
+    }
+}
+export function installTraceGlobal() {
+    if (typeof window === 'undefined')
+        return;
+    restore();
+    const api = {
+        on(...channels) {
+            for (const ch of channels)
+                enabled.add(ch);
+            persist();
+            return [...enabled];
+        },
+        off(...channels) {
+            for (const ch of channels)
+                enabled.delete(ch);
+            persist();
+            return [...enabled];
+        },
+        all() {
+            for (const ch of ALL_CHANNELS)
+                enabled.add(ch);
+            persist();
+            return [...enabled];
+        },
+        none() {
+            enabled.clear();
+            persist();
+            return [];
+        },
+        status() {
+            return [...enabled];
+        },
+        channels: ALL_CHANNELS,
+    };
+    Object.defineProperty(window, '__trace', {
+        configurable: true,
+        enumerable: true,
+        value: api,
+    });
+}