videobook 0.0.0-stage → 0.2.0

package/dist/library-browse.js

@@ -0,0 +1,78 @@
+export const LIBRARY_BROWSE_STATUSES = [
+    "ready",
+    "processing",
+    "error",
+    "all",
+];
+const READY_STATUS = "ready";
+const ERROR_STATUS = "error";
+export function isLibraryBrowseStatus(value) {
+    return value === "ready"
+        || value === "processing"
+        || value === "error"
+        || value === "all";
+}
+function isLibraryBrowseRow(asset) {
+    return asset.type === "image"
+        || asset.type === "video"
+        || asset.type === "audio"
+        || asset.type === "final";
+}
+function isProcessingStatus(status) {
+    return status !== READY_STATUS && status !== ERROR_STATUS;
+}
+export function matchesBrowseStatus(status, browseStatus) {
+    if (browseStatus === "all")
+        return true;
+    if (browseStatus === "ready")
+        return status === READY_STATUS;
+    if (browseStatus === "error")
+        return status === ERROR_STATUS;
+    return isProcessingStatus(status);
+}
+export function emptyStatusCounts() {
+    return { ready: 0, processing: 0, error: 0 };
+}
+export function addStatusCounts(left, right) {
+    return {
+        ready: left.ready + right.ready,
+        processing: left.processing + right.processing,
+        error: left.error + right.error,
+    };
+}
+export function countBrowseStatuses(assets) {
+    const counts = emptyStatusCounts();
+    for (const asset of assets) {
+        if (asset.status === READY_STATUS)
+            counts.ready += 1;
+        else if (asset.status === ERROR_STATUS)
+            counts.error += 1;
+        else
+            counts.processing += 1;
+    }
+    return counts;
+}
+export function pageLibraryAssets(assets, input) {
+    const browseStatus = input.browseStatus;
+    const offset = input.offset ?? 0;
+    const limit = input.limit ?? 200;
+    const eligible = browseStatus === undefined
+        ? [...assets]
+        : assets.filter(isLibraryBrowseRow);
+    const statusCounts = countBrowseStatuses(eligible.filter(isLibraryBrowseRow));
+    const matching = browseStatus === undefined
+        ? eligible
+        : eligible.filter((asset) => matchesBrowseStatus(asset.status, browseStatus));
+    const pageAssets = matching.slice(offset, offset + limit);
+    return {
+        matching,
+        pageAssets,
+        page: {
+            offset,
+            limit,
+            total: matching.length,
+            hasMore: offset + pageAssets.length < matching.length,
+        },
+        statusCounts,
+    };
+}

package/dist/lightning-defaults.js

@@ -0,0 +1,206 @@
+export const LIGHTNING_SCENE_MODEL = "kie:nano-banana-2-1";
+export const LIGHTNING_SCENE_ASPECT_RATIO = "16:9";
+export const LIGHTNING_SCENE_RESOLUTION = "2K";
+export const LIGHTNING_SCENE_OUTPUT_FORMAT = "jpg";
+export const LIGHTNING_SCENE_PROMPT_WORDS = 25;
+export const LIGHTNING_VIDEO_MODEL = "kie:bytedance/seedance-2-5";
+export const LIGHTNING_VIDEO_ASPECT_RATIO = "16:9";
+export const LIGHTNING_VIDEO_RESOLUTION = "1080p";
+export const LIGHTNING_VIDEO_DURATION_SECONDS = 13;
+export const LIGHTNING_VIDEO_OUTPUT_FORMAT = "mp4";
+export const LIGHTNING_VIDEO_GENERATE_AUDIO = true;
+export const LIGHTNING_VIDEO_PROMPT_WORDS = 60;
+export const LIGHTNING_VIDEO_OPTIONS = {
+    resolution: LIGHTNING_VIDEO_RESOLUTION,
+    aspect_ratio: LIGHTNING_VIDEO_ASPECT_RATIO,
+    duration: LIGHTNING_VIDEO_DURATION_SECONDS,
+    output_format: LIGHTNING_VIDEO_OUTPUT_FORMAT,
+    generate_audio: LIGHTNING_VIDEO_GENERATE_AUDIO,
+};
+export const LIGHTNING_SCENE_OPTIONS = {
+    aspect_ratio: LIGHTNING_SCENE_ASPECT_RATIO,
+    resolution: LIGHTNING_SCENE_RESOLUTION,
+    output_format: LIGHTNING_SCENE_OUTPUT_FORMAT,
+};
+export const LIGHTNING_COLD_OPEN_SECONDS = 2.3;
+const LIGHTNING_HANDLE_SECONDS = 3;
+const LIGHTNING_QR_LEAD_SECONDS = 2.3;
+export const LIGHTNING_FADE_SECONDS = 0.3;
+const LIGHTNING_POST_PLATFORM = "tiktok";
+export const LIGHTNING_POST_LANGUAGE = "th";
+export const LIGHTNING_POST_TAGS = ["fyp", "bkk"];
+export const LIGHTNING_WATERMARK_PROFILE = {
+    platform: "tiktok",
+    handle: "jtbkk",
+    profileUrl: "https://www.tiktok.com/@jtbkk",
+    includePlatformIcon: true,
+    includeHandleBorder: true,
+    handlePaddingX: 15,
+    handlePaddingY: 12,
+    handleRounding: 56,
+    scale: 1,
+    mode: "burn",
+    handlePlacement: "center",
+    handleVerticalPercent: 10,
+    handleStartSeconds: 0,
+    handleEndSeconds: LIGHTNING_HANDLE_SECONDS,
+    handleOpacity: 0.28,
+    qrPosition: "bottom-right",
+    qrLeadSeconds: LIGHTNING_QR_LEAD_SECONDS,
+    qrOpacity: 0.37,
+    fadeSeconds: LIGHTNING_FADE_SECONDS,
+};
+export const X_WATERMARK_PROFILE = {
+    platform: "x",
+    handle: "justinwtanner",
+    profileUrl: "",
+    includePlatformIcon: true,
+    includeHandleBorder: true,
+    handlePaddingX: 32,
+    handlePaddingY: 32,
+    handleRounding: 100,
+    scale: 1,
+    mode: "burn",
+    handlePlacement: "center",
+    handleVerticalPercent: 33,
+    handleStartSeconds: 0,
+    handleEndSeconds: null,
+    handleOpacity: 0.5,
+    qrPosition: "auto",
+    qrLeadSeconds: null,
+    qrOpacity: 0.5,
+    fadeSeconds: 0.5,
+};
+export function watermarkProfileToSave(base, appearance, timing) {
+    if (!timing.explicit) {
+        return {
+            ...appearance,
+            handleStartSeconds: base.handleStartSeconds,
+            handleEndSeconds: base.handleEndSeconds,
+            qrLeadSeconds: base.qrLeadSeconds,
+            qrStartSeconds: null,
+            qrEndSeconds: null,
+        };
+    }
+    return {
+        ...appearance,
+        handleStartSeconds: timing.handleStartSeconds ?? base.handleStartSeconds,
+        handleEndSeconds: timing.handleEndSeconds ?? null,
+        qrLeadSeconds: null,
+        qrStartSeconds: timing.qrStartSeconds ?? null,
+        qrEndSeconds: timing.qrEndSeconds ?? null,
+    };
+}
+const PROFILE_KEYS = [
+    "handle",
+    "profileUrl",
+    "includePlatformIcon",
+    "includeHandleBorder",
+    "handlePaddingX",
+    "handlePaddingY",
+    "handleRounding",
+    "scale",
+    "mode",
+    "handlePlacement",
+    "handleVerticalPercent",
+    "handleStartSeconds",
+    "handleEndSeconds",
+    "handleOpacity",
+    "qrPosition",
+    "qrLeadSeconds",
+    "qrOpacity",
+    "fadeSeconds",
+];
+function definedProfileFields(stored) {
+    if (!stored)
+        return {};
+    const next = {};
+    for (const key of PROFILE_KEYS) {
+        const value = stored[key];
+        if (value !== undefined)
+            next[key] = value;
+    }
+    return next;
+}
+export function watermarkProfileFor(platform, stored) {
+    const base = platform === "tiktok" ? LIGHTNING_WATERMARK_PROFILE : X_WATERMARK_PROFILE;
+    return { ...base, ...definedProfileFields(stored), platform };
+}
+function canonicalWatermarkProfile(profile) {
+    return watermarkProfileFor(profile.platform, profile);
+}
+export function watermarkWindowsFor(profile, durationSeconds) {
+    const duration = Number.isFinite(durationSeconds) ? Math.max(0, durationSeconds) : 0;
+    const handleStart = Math.min(duration, Math.max(0, profile.handleStartSeconds));
+    const handleEnd = profile.handleEndSeconds == null
+        ? duration
+        : Math.min(duration, Math.max(handleStart, profile.handleEndSeconds));
+    const qrEnd = duration;
+    const lead = profile.qrLeadSeconds;
+    const qrStart = lead == null ? 0 : Math.max(0, duration - Math.min(duration, Math.max(0, lead)));
+    return {
+        handleStartSeconds: handleStart,
+        handleEndSeconds: handleEnd,
+        qrStartSeconds: qrStart,
+        qrEndSeconds: qrEnd,
+    };
+}
+export function suggestedColdOpen(durationSeconds) {
+    const duration = Number.isFinite(durationSeconds) ? Math.max(0, durationSeconds) : 0;
+    const minimum = 0.5;
+    const preferred = Math.min(duration, LIGHTNING_COLD_OPEN_SECONDS);
+    const endSeconds = preferred >= minimum || duration < minimum ? preferred : Math.min(duration, minimum);
+    return { startSeconds: 0, endSeconds };
+}
+function finiteSeconds(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.round(value * 1000) / 1000 : null;
+}
+export function finishingIdentityKey(input) {
+    const round = (value) => Math.round(value * 1000) / 1000;
+    const qrStart = finiteSeconds(input.qrStartSeconds !== undefined ? input.qrStartSeconds : input.profile.qrStartSeconds);
+    const qrEnd = finiteSeconds(input.qrEndSeconds !== undefined ? input.qrEndSeconds : input.profile.qrEndSeconds);
+    return JSON.stringify({
+        sourceObjectHash: input.sourceObjectHash,
+        startSeconds: round(input.startSeconds),
+        endSeconds: round(input.endSeconds),
+        profile: canonicalWatermarkProfile(input.profile),
+        ...(qrStart === null && qrEnd === null ? {} : { qrStartSeconds: qrStart, qrEndSeconds: qrEnd }),
+    });
+}
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+export function preservedPrompt(value, maxWords, authored) {
+    const trimmed = value.trim();
+    if (authored || maxWords < 1)
+        return trimmed;
+    const words = trimmed.split(/\s+/u).filter(Boolean);
+    return words.length <= maxWords ? trimmed : words.slice(0, maxWords).join(" ");
+}
+export function submittedGenerationPrompt(input) {
+    const dispatched = text(input.dispatchedPrompt);
+    if (dispatched)
+        return dispatched;
+    return text(input.cellPrompt);
+}
+export function freshPostLanguage(platform, language) {
+    if (language === "en" || language === "th")
+        return language;
+    return platform === LIGHTNING_POST_PLATFORM ? LIGHTNING_POST_LANGUAGE : "en";
+}
+export function freshPostTags(platform, tags) {
+    if (tags !== undefined)
+        return [...tags];
+    return platform === LIGHTNING_POST_PLATFORM ? [...LIGHTNING_POST_TAGS] : undefined;
+}
+export function payloadPrompt(payload) {
+    if (!payload)
+        return "";
+    const input = payload.input;
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+        const nested = text(input.prompt);
+        if (nested)
+            return nested;
+    }
+    return text(payload.prompt);
+}

package/dist/load-env.js

@@ -0,0 +1,12 @@
+/**
+ * Side-effect module replacing `import "dotenv/config"`. Import this FIRST in
+ * every entry point: ESM executes it before the other imports' module bodies,
+ * so env vars are populated before any module reads them at import time. It
+ * also snapshots which managed keys were set before `.env` loaded, which is
+ * how the secret store tells 1Password-injected keys from `.env`-backed ones,
+ * then resolves op:// references and the configured vault through `op`.
+ */
+import { getDefaultSecretStore } from "./env-secrets.js";
+const store = getDefaultSecretStore();
+store.loadDotenv();
+store.resolveOnePassword();

package/dist/local-search-models.js

@@ -0,0 +1,206 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import sharp from "sharp";
+import { LocalClapTemporalProvider, LocalClipTemporalProvider, } from "videobook-engine";
+const clipProvidersByEngine = new WeakMap();
+const clapProvidersByEngine = new WeakMap();
+const fixturesByBookId = new Map();
+function modelCacheDir() {
+    return process.env.VIDEOBOOK_MODEL_CACHE_DIR?.trim()
+        || join(homedir(), ".cache", "videobook", "models");
+}
+function allowModelDownload() {
+    return process.env.VIDEOBOOK_MODEL_DOWNLOAD === "enabled";
+}
+export function localModelConfiguration() {
+    return {
+        modelCacheDir: modelCacheDir(),
+        allowModelDownload: allowModelDownload(),
+    };
+}
+async function withPreparationHint(model, run) {
+    try {
+        return await run();
+    }
+    catch (cause) {
+        if (cause instanceof Error && "error" in cause && cause.error && typeof cause.error === "object"
+            && "code" in cause.error && cause.error.code === "OFFLINE" && "message" in cause.error) {
+            const hint = `Local ${model} search is not ready. Run npm run prepare:search-models -- --download --models ${model} on the server, then retry.`;
+            cause.message = `${hint} ${cause.message}`;
+            cause.error.message = cause.message;
+        }
+        throw cause;
+    }
+}
+class ClipSearchProvider extends LocalClipTemporalProvider {
+    prepare(options = {}) { return withPreparationHint("visual", () => super.prepare(options)); }
+    embedText(text, options = {}) { return withPreparationHint("visual", () => super.embedText(text, options)); }
+    embedImage(path, options = {}) { return withPreparationHint("visual", () => super.embedImage(path, options)); }
+}
+class ClapSearchProvider extends LocalClapTemporalProvider {
+    prepare(options = {}) { return withPreparationHint("audio", () => super.prepare(options)); }
+    embedText(text, options = {}) { return withPreparationHint("audio", () => super.embedText(text, options)); }
+    embedAudio(path, startSeconds, durationSeconds, options = {}) {
+        return withPreparationHint("audio", () => super.embedAudio(path, startSeconds, durationSeconds, options));
+    }
+}
+function hasMatchingConfiguration(cached, current) {
+    return cached.modelCacheDir === current.modelCacheDir
+        && cached.allowModelDownload === current.allowModelDownload;
+}
+function fault(code, message) {
+    throw Object.assign(new Error(message), {
+        name: code,
+        error: { code, message },
+    });
+}
+function throwIfAborted(options = {}) {
+    if (!options.signal?.aborted)
+        return;
+    fault("CANCELLED", "Cancelled");
+}
+function invalidInput(message) {
+    fault("INVALID_INPUT", message);
+}
+function hashEmbedding(payload, dimensions) {
+    const digest = createHash("sha256").update(payload).digest();
+    const vector = new Float32Array(dimensions);
+    for (let index = 0; index < dimensions; index += 1) {
+        vector[index] = digest[index % digest.length] / 127.5 - 1;
+    }
+    let norm = 0;
+    for (const value of vector)
+        norm += value * value;
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+        for (let index = 0; index < dimensions; index += 1)
+            vector[index] /= norm;
+    }
+    return vector;
+}
+class HashClipSearchProvider extends LocalClipTemporalProvider {
+    constructor() {
+        super({ modelCacheDir: "/dev/null", allowModelDownload: false });
+    }
+    prepare(options = {}) {
+        throwIfAborted(options);
+        return Promise.resolve();
+    }
+    embedText(text, options = {}) {
+        throwIfAborted(options);
+        return Promise.resolve(hashEmbedding(text, this.dimensions));
+    }
+    async embedImage(sourcePath, options = {}) {
+        throwIfAborted(options);
+        try {
+            const decoded = await sharp(sourcePath, { failOn: "error", limitInputPixels: 40_000_000 })
+                .rotate()
+                .toColourspace("srgb")
+                .removeAlpha()
+                .raw()
+                .toBuffer();
+            return hashEmbedding(decoded, this.dimensions);
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "error" in error)
+                throw error;
+            invalidInput("Unable to decode model image within the supported limits");
+        }
+    }
+}
+class HashClapSearchProvider extends LocalClapTemporalProvider {
+    constructor() {
+        super({ modelCacheDir: "/dev/null", allowModelDownload: false, ffmpegPath: "ffmpeg" });
+    }
+    prepare(options = {}) {
+        throwIfAborted(options);
+        return Promise.resolve();
+    }
+    embedText(text, options = {}) {
+        throwIfAborted(options);
+        return Promise.resolve(hashEmbedding(text, this.dimensions));
+    }
+    async embedAudio(sourcePath, startSeconds = 0, durationSeconds = 10, options = {}) {
+        throwIfAborted(options);
+        if (!(startSeconds >= 0) || !(durationSeconds > 0)) {
+            invalidInput("CLAP audio range must have a non-negative start and positive duration");
+        }
+        const bytes = await readFile(sourcePath);
+        return hashEmbedding(Buffer.concat([bytes, Buffer.from(`${startSeconds}:${durationSeconds}`)]), this.dimensions);
+    }
+}
+export function installLocalSearchProviderFixtures(engine) {
+    const configuration = localModelConfiguration();
+    const clip = new HashClipSearchProvider();
+    const clap = new HashClapSearchProvider();
+    clipProvidersByEngine.set(engine, { ...configuration, provider: clip, fixture: true });
+    clapProvidersByEngine.set(engine, {
+        ...configuration,
+        ffmpegPath: "ffmpeg",
+        provider: clap,
+        fixture: true,
+    });
+    fixturesByBookId.set(engine.book.get().bookId, { clip, clap });
+    engine.temporalSearch.providers.register(clip, { modelDownloads: false });
+    engine.temporalSearch.providers.register(clap, { modelDownloads: false });
+}
+function fixtureProviders(engine) {
+    const cached = clipProvidersByEngine.get(engine);
+    const clap = clapProvidersByEngine.get(engine);
+    if (cached?.fixture && clap?.fixture)
+        return { clip: cached.provider, clap: clap.provider };
+    try {
+        return fixturesByBookId.get(engine.book.get().bookId);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function registerLocalClipSearchProvider(engine) {
+    const configuration = localModelConfiguration();
+    const fixture = fixtureProviders(engine);
+    if (fixture) {
+        engine.temporalSearch.providers.register(fixture.clip, { modelDownloads: false });
+        return fixture.clip;
+    }
+    const cached = clipProvidersByEngine.get(engine);
+    if (cached && hasMatchingConfiguration(cached, configuration)) {
+        engine.temporalSearch.providers.register(cached.provider, { modelDownloads: configuration.allowModelDownload });
+        return cached.provider;
+    }
+    const provider = new ClipSearchProvider(configuration);
+    clipProvidersByEngine.set(engine, {
+        ...configuration,
+        provider,
+    });
+    engine.temporalSearch.providers.register(provider, { modelDownloads: configuration.allowModelDownload });
+    return provider;
+}
+export function registerLocalClapSearchProvider(engine, ffmpegPath) {
+    const configuration = localModelConfiguration();
+    const fixture = fixtureProviders(engine);
+    if (fixture) {
+        engine.temporalSearch.providers.register(fixture.clap, { modelDownloads: false });
+        return fixture.clap;
+    }
+    const cached = clapProvidersByEngine.get(engine);
+    if (cached
+        && cached.ffmpegPath === ffmpegPath
+        && hasMatchingConfiguration(cached, configuration)) {
+        engine.temporalSearch.providers.register(cached.provider, { modelDownloads: configuration.allowModelDownload });
+        return cached.provider;
+    }
+    const provider = new ClapSearchProvider({
+        ...configuration,
+        ffmpegPath,
+    });
+    clapProvidersByEngine.set(engine, {
+        ...configuration,
+        ffmpegPath,
+        provider,
+    });
+    engine.temporalSearch.providers.register(provider, { modelDownloads: configuration.allowModelDownload });
+    return provider;
+}