@melite/formats 0.0.0-stage → 0.1.5-pre-alpha

package/lib/bodyPresets.js

@@ -0,0 +1,77 @@
+// Anny's 11 phenotype dims in order:
+//   [gender, age, muscle, weight, height, proportions, cupsize, firmness,
+//    african, asian, caucasian]
+// gender: 0.0 = masculine, 1.0 = feminine (verified against the live mesh:
+// gender=0 widens jaw and shoulders; gender=1 narrows them and widens hips).
+// age/muscle/weight: 0.5 = average adult. height/proportions: 0.5 = standard.
+// race dims are left at neutral 0.5 so race-specific features stay default.
+const NEUTRAL_RACE = [0.5, 0.5, 0.5]; // african, asian, caucasian
+/**
+ * Neutral - reset to the Anny default with no stylization.
+ *
+ * Provides a quick "back to neutral" affordance in the preset bar without
+ * the user having to hit the Reset button. Coeffs all 0.5 = Anny's neutral
+ * adult, no local changes, no custom target blends.
+ */
+const NEUTRAL = {
+    id: "neutral",
+    name: "Neutral",
+    description: "Default Anny - no stylization, no morphs",
+    identityModel: "anny",
+    coeffs: [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, ...NEUTRAL_RACE],
+    localChanges: null,
+    customTargets: null,
+};
+/**
+ * Male - basic masculine baseline with no stylization.
+ *
+ * Gender 0.0 (fully masculine → wider jaw, broader shoulders, narrower
+ * hips). Age/muscle/weight tuned to a healthy adult male build. No
+ * local_changes — this is a clean starting point the user can sculpt
+ * further. Height slightly above average.
+ */
+const MALE = {
+    id: "male",
+    name: "Male",
+    description: "Basic masculine baseline - no stylization",
+    identityModel: "anny",
+    coeffs: [0.0, 0.45, 0.55, 0.50, 0.55, 0.50, 0.40, 0.55, ...NEUTRAL_RACE],
+    //          gen  age   mus   wt    ht    prop  cup  firm
+    localChanges: null,
+    customTargets: null,
+};
+/**
+ * Female - basic feminine baseline with no stylization.
+ *
+ * Gender 1.0 (fully feminine → narrower jaw, defined waist, wider hips).
+ * Age/muscle/weight tuned to a healthy adult female build. No
+ * local_changes — clean starting point for further sculpting.
+ */
+const FEMALE = {
+    id: "female",
+    name: "Female",
+    description: "Basic feminine baseline - no stylization",
+    identityModel: "anny",
+    coeffs: [1.0, 0.40, 0.35, 0.38, 0.52, 0.52, 0.45, 0.55, ...NEUTRAL_RACE],
+    //          gen  age   mus   wt    ht    prop  cup  firm
+    localChanges: null,
+    customTargets: null,
+};
+export const BODY_PRESETS = [
+    NEUTRAL, MALE, FEMALE,
+];
+/**
+ * Find a preset by id (returns undefined if not found).
+ *
+ * Used by tests and any future "load preset by URL hash" affordances.
+ */
+export function getPresetById(id) {
+    return BODY_PRESETS.find((p) => p.id === id);
+}
+/**
+ * Default preset (the one applied to the very first Body Studio mount).
+ * Returns null so we DON'T clobber the user's saved edits on subsequent
+ * loads - the default is the un-morphed Anny.
+ */
+export const DEFAULT_PRESET_ID = null;
+//# sourceMappingURL=bodyPresets.js.map

package/lib/captionSplitter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * E3.7 — Caption text splitter.
+ *
+ * Converts a plain-text transcription into a sequence of CaptionCues with
+ * proportional timing. When the ASR backend provides word-level timestamps
+ * (via `tokens`), we use those directly. Otherwise we fall back to
+ * sentence-aware splitting with proportional duration allocation (by
+ * character count — longer sentences get proportionally more time).
+ *
+ * Caption length targets ~42 characters per cue (the industry standard
+ * for readable subtitles, per the BBC/NBC style guides). Sentences longer
+ * than that are split at clause boundaries (commas, semicolons, dashes)
+ * or at word boundaries as a last resort.
+ *
+ * Timing model: cue.start/end are SECONDS RELATIVE TO THE SEGMENT START
+ * (not the global timeline). The program monitor maps global time →
+ * segment-relative time before looking up the active cue.
+ */
+import type { CaptionCue } from "@melite/contracts";
+export interface SplitArgs {
+    /** Full transcription text. */
+    text: string;
+    /** Segment duration in seconds (the cues' timing window). */
+    duration: number;
+    /** Optional word-level timestamps from the ASR backend. When provided,
+     *  cues are built from the actual word timings instead of proportional
+     *  splitting. Each token: { text, start, end } in seconds. */
+    tokens?: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }> | null;
+    /** Max characters per cue (default 42). */
+    maxChars?: number;
+}
+/**
+ * Build CaptionCues from a transcription. Returns an empty array if the
+ * text is empty/whitespace or the duration is <= 0.
+ */
+export declare function splitCaptions(args: SplitArgs): CaptionCue[];
+/**
+ * Split text into caption-length chunks. Strategy (in priority order):
+ *   1. Split into sentences (terminators . ! ? …).
+ *   2. If a sentence exceeds maxChars, split at clause boundaries
+ *      (, ; : — –) then at word boundaries as a last resort.
+ *   3. Merge short consecutive fragments up to maxChars.
+ */
+export declare function splitIntoChunks(text: string, maxChars?: number): string[];
+//# sourceMappingURL=captionSplitter.d.ts.map

package/lib/captionSplitter.js

@@ -0,0 +1,172 @@
+const DEFAULT_MAX_CHARS = 42;
+/**
+ * Build CaptionCues from a transcription. Returns an empty array if the
+ * text is empty/whitespace or the duration is <= 0.
+ */
+export function splitCaptions(args) {
+    const { text, duration, tokens = null, maxChars = DEFAULT_MAX_CHARS } = args;
+    if (duration <= 0)
+        return [];
+    // ── Timestamped path takes precedence — tokens can build cues even
+    //    with empty text (the text is derived from the tokens). ─────────────
+    if (tokens && tokens.length > 0) {
+        return buildFromTokens(tokens, maxChars, duration);
+    }
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    // ── Proportional path: split text + distribute by character count ──────
+    const chunks = splitIntoChunks(trimmed, maxChars);
+    
+
+
+    if (chunks.length === 0)
+        return [];
+    const totalChars = chunks.reduce((s, c) => s + c.length, 0);
+    let elapsed = 0;
+    return chunks.map((chunk, i) => {
+        
+        // chunks.length guard above), so totalChars is positive — no fallback.
+        const proportion = chunk.length / totalChars;
+        const start = elapsed;
+        const segDur = proportion * duration;
+        // Last cue gets the remaining time (avoids float drift at the end).
+        const end = i === chunks.length - 1 ? duration : Math.min(duration, start + segDur);
+        elapsed = end;
+        return {
+            id: `cap_${i}_${Math.random().toString(36).slice(2, 8)}`,
+            start: Number(start.toFixed(3)),
+            end: Number(end.toFixed(3)),
+            text: chunk,
+        };
+    });
+}
+/**
+ * Split text into caption-length chunks. Strategy (in priority order):
+ *   1. Split into sentences (terminators . ! ? …).
+ *   2. If a sentence exceeds maxChars, split at clause boundaries
+ *      (, ; : — –) then at word boundaries as a last resort.
+ *   3. Merge short consecutive fragments up to maxChars.
+ */
+export function splitIntoChunks(text, maxChars = DEFAULT_MAX_CHARS) {
+    // Normalize whitespace.
+    const clean = text.replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return [];
+    // Step 1: split into sentences, keeping the terminator.
+    // The second alternative matches any trailing non-space run, so a
+    // non-empty input always yields >=1 match (the `as` is proven, not blind:
+    // `clean` is non-empty per the guard above).
+    const sentences = clean.match(/[^.!?…]+[.!?…]+|\S[^.!?…]*$/g);
+    // Step 2: break long sentences at clause / word boundaries.
+    const fragments = [];
+    for (const s of sentences) {
+        const trimmed = s.trim();
+        
+
+
+        if (!trimmed)
+            continue;
+        if (trimmed.length <= maxChars) {
+            fragments.push(trimmed);
+        }
+        else {
+            fragments.push(...splitLongSentence(trimmed, maxChars));
+        }
+    }
+    // Step 3: greedily merge short fragments up to maxChars.
+    return mergeFragments(fragments, maxChars);
+}
+/** Split a long sentence at clause boundaries, then word boundaries. */
+function splitLongSentence(s, maxChars) {
+    // Try clause boundaries first: , ; : — –
+    const clauseParts = s.split(/(?<=[,;:—–])\s+/).map((p) => p.trim()).filter(Boolean);
+    if (clauseParts.length > 1) {
+        return clauseParts.flatMap((p) => p.length <= maxChars ? [p] : splitAtWordBoundary(p, maxChars));
+    }
+    // No clause boundaries — split at word boundaries.
+    return splitAtWordBoundary(s, maxChars);
+}
+/** Split at word boundaries, each chunk <= maxChars. */
+function splitAtWordBoundary(s, maxChars) {
+    const words = s.split(/\s+/);
+    const chunks = [];
+    let cur = '';
+    for (const w of words) {
+        if ((cur + ' ' + w).trim().length <= maxChars) {
+            cur = (cur + ' ' + w).trim();
+        }
+        else {
+            if (cur)
+                chunks.push(cur);
+            cur = w;
+        }
+    }
+    
+    if (cur)
+        chunks.push(cur);
+    return chunks;
+}
+/** Greedily merge short fragments that fit within maxChars. */
+function mergeFragments(frags, maxChars) {
+    const merged = [];
+    let cur = '';
+    for (const f of frags) {
+        const candidate = cur ? `${cur} ${f}` : f;
+        if (candidate.length <= maxChars) {
+            cur = candidate;
+        }
+        else {
+            if (cur)
+                merged.push(cur);
+            cur = f;
+        }
+    }
+    
+
+    if (cur)
+        merged.push(cur);
+    return merged;
+}
+/** Build cues from timestamped word tokens, grouping words into cues. */
+function buildFromTokens(tokens, maxChars, fallbackDuration) {
+    const cues = [];
+    let curWords = [];
+    let curLen = 0;
+    for (const tok of tokens) {
+        const addedLen = (curLen > 0 ? 1 : 0) + tok.text.length;
+        if (curLen + addedLen > maxChars && curWords.length > 0) {
+            // Flush the current group.
+            cues.push(makeTokenCue(curWords, cues.length));
+            curWords = [];
+            curLen = 0;
+        }
+        curWords.push(tok);
+        curLen += (curLen > 0 ? 1 : 0) + tok.text.length;
+    }
+    
+
+
+    if (curWords.length > 0) {
+        cues.push(makeTokenCue(curWords, cues.length));
+    }
+    // Clamp the last cue's end to the segment duration if tokens overshoot.
+    
+
+    if (cues.length > 0) {
+        const last = cues[cues.length - 1];
+        if (last.end > fallbackDuration) {
+            last.end = fallbackDuration;
+        }
+    }
+    return cues;
+}
+function makeTokenCue(words, idx) {
+    return {
+        id: `cap_${idx}_${Math.random().toString(36).slice(2, 8)}`,
+        start: Number(words[0].start.toFixed(3)),
+        end: Number(words[words.length - 1].end.toFixed(3)),
+        text: words.map((w) => w.text).join(' '),
+    };
+}
+//# sourceMappingURL=captionSplitter.js.map

package/lib/cardMutations.d.ts

@@ -0,0 +1,52 @@
+/** Max length of a card title / flow name, enforced by this gate at edit time. The wire types carry titles as bare strings — the gate is the bound's single home. */
+export declare const TITLE_MAX_LEN = 120;
+export interface MutationSpec {
+    /** The field this mutation writes (the patch key). */
+    field: string;
+    /** Coerce the raw value before validation (trim). */
+    coerce: (v: unknown) => unknown;
+    /** Type-guard gate: string, non-empty after trim, <= TITLE_MAX_LEN. */
+    validate: (v: unknown) => v is string;
+}
+/** The closed set of stage mutations. Add a member + a CARD_MUTATIONS entry
+ * to extend the gate. */
+export type StageMutationKind = "rename";
+export type StageMutation = {
+    kind: "rename";
+    value: string;
+};
+export declare const CARD_MUTATIONS: Record<StageMutationKind, MutationSpec>;
+export type StageMutationResult = {
+    ok: true;
+    patch: {
+        title: string;
+    };
+} | {
+    ok: false;
+    error: string;
+};
+/** Pure gate. Unknown kinds error at runtime (defense in depth beyond the
+ * tsc union). Every card mutation must pass through here. */
+export declare function applyStageMutation(mutation: StageMutation): StageMutationResult;
+
+
+export type DocMutationKind = "rename";
+export type DocMutation = {
+    kind: "rename";
+    value: string;
+};
+export declare const DOC_MUTATIONS: Record<DocMutationKind, MutationSpec>;
+export type DocMutationResult = {
+    ok: true;
+    patch: {
+        name: string;
+    };
+} | {
+    ok: false;
+    error: string;
+};
+/** Pure gate for flow-doc mutations — the flow-level sibling of
+ * applyStageMutation. Cosmetic: the store action must NOT mark stale or
+ * recompute keys (a rename is not a semantic change). */
+export declare function applyDocMutation(mutation: DocMutation): DocMutationResult;
+//# sourceMappingURL=cardMutations.d.ts.map

package/lib/cardMutations.js

@@ -0,0 +1,67 @@
+
+//
+// DECLARATIVE way. One table, one gate — no per-kind imperative store code.
+// Each row declares the field a mutation kind writes + its validation
+// + coercion; extending the gate = adding a union member + a table row
+// (same discipline as _FORM_CONFIGS: one table the gate mirrors).
+//
+// The enforcement is two-layer, mirroring the catalog schema's pattern:
+// • HERE (frontend, edit time): the typed unions (tsc) + this runtime gate —
+// every card/doc mutation passes through applyStageMutation /
+// applyDocMutation (the shared runMutation core).
+// • WIRE (run start): FlowDoc.title AND BackendStage.title in FlowTypes.ts are bare strings — this gate is the bound's single home; a title that passes here fits the wire.
+// Bump all together.
+//
+
+// name gets a row in one of these tables + a bound in the owning layer
+// (this gate where the card owns the name, the wire contract where the
+// run owns it). No ad-hoc name writes — that's how drift and breakage
+// creep in.
+/** Max length of a card title / flow name, enforced by this gate at edit time. The wire types carry titles as bare strings — the gate is the bound's single home. */
+export const TITLE_MAX_LEN = 120;
+/** Shared core: coerce → validate → patch. Every table's apply* entry is a
+ * thin wrapper over this — one gate, one error language across targets. */
+function runMutation(spec, value) {
+    const v = spec.coerce(value);
+    if (!spec.validate(v)) {
+        return {
+            ok: false,
+            error: `Invalid ${spec.field}: must be 1-${TITLE_MAX_LEN} non-empty characters`,
+        };
+    }
+    return { ok: true, patch: { [spec.field]: v } };
+}
+export const CARD_MUTATIONS = {
+    rename: {
+        field: "title",
+        coerce: (v) => (typeof v === "string" ? v.trim() : v),
+        validate: (v) => typeof v === "string" && v.trim().length > 0 && v.trim().length <= TITLE_MAX_LEN,
+    },
+};
+/** Pure gate. Unknown kinds error at runtime (defense in depth beyond the
+ * tsc union). Every card mutation must pass through here. */
+export function applyStageMutation(mutation) {
+    const spec = CARD_MUTATIONS[mutation.kind];
+    if (!spec) {
+        return { ok: false, error: `Unknown stage mutation kind: ${mutation.kind}` };
+    }
+    return runMutation(spec, mutation.value);
+}
+export const DOC_MUTATIONS = {
+    rename: {
+        field: "name",
+        coerce: (v) => (typeof v === "string" ? v.trim() : v),
+        validate: (v) => typeof v === "string" && v.trim().length > 0 && v.trim().length <= TITLE_MAX_LEN,
+    },
+};
+/** Pure gate for flow-doc mutations — the flow-level sibling of
+ * applyStageMutation. Cosmetic: the store action must NOT mark stale or
+ * recompute keys (a rename is not a semantic change). */
+export function applyDocMutation(mutation) {
+    const spec = DOC_MUTATIONS[mutation.kind];
+    if (!spec) {
+        return { ok: false, error: `Unknown doc mutation kind: ${mutation.kind}` };
+    }
+    return runMutation(spec, mutation.value);
+}
+//# sourceMappingURL=cardMutations.js.map

package/lib/downloads.d.ts

@@ -0,0 +1,18 @@
+/** downloads - browser download triggers for pose artifacts
+ * (ex-lib/text-to-pose export helpers). */
+import type { PoseMotion } from "./textToPose.js";
+/**
+ * Trigger a browser download from a base64-encoded payload.
+ * Mirrors Kimodo demo's _download_bytes_to_browser (ui.py).
+ */
+export declare function downloadBase64Payload(b64: string, filename: string, mimeType?: string): void;
+/**
+ * Download the SOMA-77 motion as an .npz file (poses + rotmats + deformed verts).
+ */
+export declare function downloadMotionNpz(motion: PoseMotion, filename?: string): void;
+/**
+ * Capture the largest <canvas> on the page as a PNG download.
+ * Used for screenshots of the 3D viewer.
+ */
+export declare function downloadCanvasScreenshot(filename?: string): void;
+//# sourceMappingURL=downloads.d.ts.map

package/lib/downloads.js

@@ -0,0 +1,64 @@
+// ── Export helpers ─────────────────────────────────────────────────────────
+/**
+ * Trigger a browser download from a base64-encoded payload.
+ * Mirrors Kimodo demo's _download_bytes_to_browser (ui.py).
+ */
+export function downloadBase64Payload(b64, filename, mimeType = "application/octet-stream") {
+    let binStr;
+    try {
+        binStr = atob(b64);
+    }
+    catch {
+        console.error("downloadBase64Payload: invalid base64 string");
+        return;
+    }
+    const bytes = new Uint8Array(binStr.length);
+    for (let i = 0; i < binStr.length; i++)
+        bytes[i] = binStr.charCodeAt(i);
+    const blob = new Blob([bytes], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+}
+/**
+ * Download the SOMA-77 motion as an .npz file (poses + rotmats + deformed verts).
+ */
+export function downloadMotionNpz(motion, filename = "motion.npz") {
+    if (!motion.soma_npz_b64)
+        throw new Error("No NPZ data in motion result");
+    downloadBase64Payload(motion.soma_npz_b64, filename, "application/octet-stream");
+}
+/**
+ * Capture the largest <canvas> on the page as a PNG download.
+ * Used for screenshots of the 3D viewer.
+ */
+export function downloadCanvasScreenshot(filename = "pose.png") {
+    const canvases = Array.from(document.querySelectorAll("canvas"));
+    if (!canvases.length)
+        return;
+    const canvas = canvases.reduce((best, cur) => {
+        const ba = (best?.width || 0) * (best?.height || 0);
+        const ca = (cur.width || 0) * (cur.height || 0);
+        return ca > ba ? cur : best;
+    }, null);
+    if (!canvas)
+        return;
+    canvas.toBlob((blob) => {
+        if (!blob)
+            return;
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        a.remove();
+        URL.revokeObjectURL(url);
+    }, "image/png");
+}
+//# sourceMappingURL=downloads.js.map

package/lib/extractVideoFrame.d.ts

@@ -0,0 +1,23 @@
+/**
+ * E3.8 — Client-side video frame extraction.
+ *
+ * Extracts a single frame from a video at a given timestamp by seeking
+ * a hidden <video> element and drawing it to a <canvas>. Returns a PNG
+ * data URL, or null if extraction fails (best-effort — the caller
+ * continues without a first-frame anchor rather than blocking).
+ *
+ * Used by the SmartSplit flow to grab the opening frame of each detected
+ * scene and set it as the segment's firstFrameB64 anchor.
+ */
+/**
+ * Extract a frame from `videoUrl` at `timeSeconds`.
+ * @returns PNG data URL, or null on any failure.
+ */
+export declare function extractVideoFrame(videoUrl: string, timeSeconds: number): Promise<string | null>;
+/**
+ * Extract the opening frame for each scene in parallel (bounded — at most
+ * `concurrency` extractions in flight at once). Returns an array aligned
+ * with the input `times` (null where extraction failed).
+ */
+export declare function extractFramesBatch(videoUrl: string, times: number[], concurrency?: number): Promise<(string | null)[]>;
+//# sourceMappingURL=extractVideoFrame.d.ts.map

package/lib/extractVideoFrame.js

@@ -0,0 +1,114 @@
+/**
+ * E3.8 — Client-side video frame extraction.
+ *
+ * Extracts a single frame from a video at a given timestamp by seeking
+ * a hidden <video> element and drawing it to a <canvas>. Returns a PNG
+ * data URL, or null if extraction fails (best-effort — the caller
+ * continues without a first-frame anchor rather than blocking).
+ *
+ * Used by the SmartSplit flow to grab the opening frame of each detected
+ * scene and set it as the segment's firstFrameB64 anchor.
+ */
+/**
+ * Extract a frame from `videoUrl` at `timeSeconds`.
+ * @returns PNG data URL, or null on any failure.
+ */
+export async function extractVideoFrame(videoUrl, timeSeconds) {
+    return new Promise((resolve) => {
+        if (!videoUrl || timeSeconds < 0) {
+            resolve(null);
+            return;
+        }
+        const video = document.createElement('video');
+        video.src = videoUrl;
+        video.crossOrigin = 'anonymous';
+        video.muted = true;
+        video.preload = 'auto';
+        video.playsInline = true;
+        let settled = false;
+        const cleanup = () => {
+            video.removeAttribute('src');
+            try {
+                video.load();
+            }
+            catch { /* noop */ }
+        };
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
+        // Timeout — if the video can't seek in 5s, give up.
+        const timer = setTimeout(() => done(null), 5000);
+        video.onloadedmetadata = () => {
+            // Clamp the seek time to the video duration.
+            const t = Math.min(timeSeconds, Math.max(0, (video.duration || timeSeconds) - 0.05));
+            try {
+                video.currentTime = t;
+            }
+            catch {
+                // Browser API: currentTime setter throws if the media isn't seekable
+                // yet (e.g. blob not fully loaded). Same policy exemption as play()/
+                // fullscreen — browser-API rejection, not a backend failure.
+                clearTimeout(timer);
+                done(null);
+            }
+        };
+        video.onseeked = () => {
+            clearTimeout(timer);
+            try {
+                const canvas = document.createElement('canvas');
+                // Cap the extraction resolution to keep data URLs manageable.
+                // The generation model snaps to VAE factors anyway, so a 512px
+                // long edge is plenty for a first-frame anchor.
+                const maxDim = 512;
+                const vw = video.videoWidth || 640;
+                const vh = video.videoHeight || 480;
+                const scale = Math.min(1, maxDim / Math.max(vw, vh));
+                canvas.width = Math.round(vw * scale);
+                canvas.height = Math.round(vh * scale);
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    done(null);
+                    return;
+                }
+                ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+                const dataUrl = canvas.toDataURL('image/png');
+                done(dataUrl || null);
+            }
+            catch (e) {
+                // NO SILENT SWALLOW — canvas drawing can fail on tainted cross-origin
+                // media or if the video element is in an invalid state. Log so we know
+                // when frame extraction is silently falling back to null.
+                console.error('[extract-video-frame] canvas draw/toDataURL failed:', e);
+                done(null);
+            }
+        };
+        video.onerror = () => {
+            clearTimeout(timer);
+            done(null);
+        };
+    });
+}
+/**
+ * Extract the opening frame for each scene in parallel (bounded — at most
+ * `concurrency` extractions in flight at once). Returns an array aligned
+ * with the input `times` (null where extraction failed).
+ */
+export async function extractFramesBatch(videoUrl, times, concurrency = 3) {
+    const results = new Array(times.length).fill(null);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(concurrency, times.length) }, async () => {
+        while (true) {
+            const idx = next++;
+            if (idx >= times.length)
+                break;
+            results[idx] = await extractVideoFrame(videoUrl, times[idx]);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+//# sourceMappingURL=extractVideoFrame.js.map