videobook 0.0.0-stage → 0.2.0

package/dist/downloads-dest.js

@@ -0,0 +1,56 @@
+import { copyFile, lstat } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function defaultDownloadsDir() {
+    return process.env.VIDEOBOOK_DOWNLOADS_DIR || join(homedir(), "Downloads");
+}
+/** Flatten a display label into a single Downloads filename stem.
+ *  Generation labels include model slugs like `kling-3.0/video — …`; those
+ *  slashes (and `..` / backslashes) must not become path segments. */
+function sanitizeDownloadBaseName(baseName) {
+    const parts = baseName.split(/[/\\]+/u).flatMap((part) => {
+        const trimmed = part.replaceAll("\0", "").trim();
+        if (!trimmed || trimmed === "." || trimmed === "..")
+            return [];
+        return [trimmed];
+    });
+    const joined = parts.join(" - ").replace(/\s+/gu, " ").trim();
+    return joined || "download";
+}
+export async function resolveDownloadDestination(baseName, ext, downloadsDir = defaultDownloadsDir()) {
+    const stem = sanitizeDownloadBaseName(baseName);
+    const suffix = ext.startsWith(".") ? ext : `.${ext}`;
+    let candidate = join(downloadsDir, `${stem}${suffix}`);
+    let n = 2;
+    while (await fileExists(candidate)) {
+        candidate = join(downloadsDir, `${stem} (${n})${suffix}`);
+        n += 1;
+    }
+    return candidate;
+}
+async function fileExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function copyToDownloads(sourcePath, baseName, ext, downloadsDir) {
+    while (true) {
+        const destination = await resolveDownloadDestination(baseName, ext, downloadsDir);
+        try {
+            await copyFile(sourcePath, destination, fsConstants.COPYFILE_EXCL);
+            return destination;
+        }
+        catch (error) {
+            if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST")
+                continue;
+            throw error;
+        }
+    }
+}

package/dist/editing-moments.js

@@ -0,0 +1,194 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { readVideoAnalysisSummary } from "./video-analysis-projection.js";
+const MOMENTS_SCHEMA_VERSION = 1;
+export const MOMENTS_EXTRACTOR_ID = "videobook-scene-scan";
+export const MOMENTS_EXTRACTOR_VERSION = "1";
+export const MOMENTS_SHOT_THRESHOLD = 0.3;
+export const MOMENTS_CHANGE_THRESHOLD = 0.12;
+export const MOMENTS_MIN_MOMENT_SECONDS = 0.5;
+export const MOMENTS_MAX_SCAN_SECONDS = 1800;
+const MOMENTS_MAX_SHOTS = 4000;
+export const MOMENTS_MAX_RANKED = 12;
+const rangeSchema = z.object({
+    startSeconds: z.number().finite().nonnegative(),
+    endSeconds: z.number().finite().positive(),
+});
+const shotSchema = z.object({
+    id: z.string().min(1).max(100),
+    startSeconds: z.number().finite().nonnegative(),
+    endSeconds: z.number().finite().positive(),
+    motion: z.number().min(0).max(1),
+    change: z.object({
+        timeSeconds: z.number().finite().nonnegative(),
+        strength: z.number().min(0).max(1),
+        quality: z.number().min(0).max(1),
+    }).nullable(),
+});
+export const editingMomentsSchema = z.object({
+    schemaVersion: z.literal(MOMENTS_SCHEMA_VERSION),
+    momentsId: z.string().min(1),
+    artifactId: z.string().uuid(),
+    objectHash: z.string().min(1),
+    streamId: z.string().uuid(),
+    durationSeconds: z.number().finite().positive(),
+    extractor: z.object({
+        id: z.string().min(1),
+        version: z.string().min(1),
+        params: z.object({
+            shotThreshold: z.number(),
+            changeThreshold: z.number(),
+            minMomentSeconds: z.number(),
+        }),
+    }),
+    analyzedRanges: z.array(rangeSchema).min(1),
+    createdAt: z.number().finite().positive(),
+    shots: z.array(shotSchema).max(MOMENTS_MAX_SHOTS),
+    usable: z.array(rangeSchema),
+    moments: z.array(z.object({
+        shotId: z.string().min(1),
+        startSeconds: z.number().finite().nonnegative(),
+        endSeconds: z.number().finite().positive(),
+        score: z.number().min(0).max(1),
+        quality: z.number().min(0).max(1),
+    })).max(MOMENTS_MAX_SHOTS),
+    reused: z.object({
+        visionAnalysis: z.object({
+            summary: z.string(),
+            tags: z.array(z.string()),
+            subjects: z.array(z.string()),
+            sceneCount: z.number().int().nonnegative(),
+            timestampsApproximate: z.literal(true),
+        }).nullable(),
+        indexCoverage: z.object({
+            state: z.string(),
+            generation: z.string(),
+        }).nullable(),
+    }),
+});
+export function editingMomentsId(input) {
+    return createHash("sha256").update(JSON.stringify([
+        input.objectHash, input.streamIndex, MOMENTS_EXTRACTOR_ID, MOMENTS_EXTRACTOR_VERSION,
+        input.startSeconds, input.endSeconds,
+    ])).digest("hex");
+}
+export function editingMomentsCacheKey(momentsId) {
+    return `editing.moments.${momentsId}`;
+}
+export async function readEditingMoments(engine, artifactId, momentsId) {
+    const read = await engine.metadata.artifacts.read(artifactId, editingMomentsCacheKey(momentsId));
+    if (!read.ok)
+        return null;
+    const parsed = editingMomentsSchema.safeParse(read.value);
+    if (!parsed.success || parsed.data.artifactId !== artifactId || parsed.data.momentsId !== momentsId)
+        return null;
+    return parsed.data;
+}
+export async function reuseContext(engine, artifactId) {
+    const summary = await readVideoAnalysisSummary(engine, artifactId);
+    let coverage = null;
+    try {
+        const state = engine.temporalSearch.coverage(artifactId);
+        coverage = state.ok ? { state: state.value.state, generation: state.value.generation } : null;
+    }
+    catch {
+        coverage = null;
+    }
+    return {
+        visionAnalysis: summary ? {
+            summary: summary.summary,
+            tags: summary.tags,
+            subjects: summary.subjects,
+            sceneCount: summary.scene_count,
+            timestampsApproximate: true,
+        } : null,
+        indexCoverage: coverage,
+    };
+}
+const round = (value) => Math.round(value * 10000) / 10000;
+export function shotsFromScan(frames, durationSeconds) {
+    const boundaries = shotBoundaries(frames);
+    const edges = [0, ...boundaries, durationSeconds];
+    let cursor = 0;
+    return edges.slice(0, -1).map((start, index) => {
+        const end = edges[index + 1];
+        while (cursor < frames.length && frames[cursor].timeSeconds < start)
+            cursor += 1;
+        const samples = [];
+        for (let probe = cursor; probe < frames.length && frames[probe].timeSeconds < end; probe += 1) {
+            samples.push(frames[probe]);
+        }
+        return buildShot(`shot-${index + 1}`, start, end, samples);
+    }).filter((shot) => shot.endSeconds - shot.startSeconds > 0);
+}
+function shotBoundaries(frames) {
+    const peaks = [];
+    for (let index = 1; index < frames.length - 1; index += 1) {
+        const frame = frames[index];
+        if (frame.score < MOMENTS_SHOT_THRESHOLD)
+            continue;
+        if (frame.score < frames[index - 1].score || frame.score < frames[index + 1].score)
+            continue;
+        peaks.push({ timeSeconds: frame.timeSeconds, score: frame.score });
+    }
+    const kept = [];
+    for (const peak of [...peaks].sort((left, right) => right.score - left.score)) {
+        if (kept.every((time) => Math.abs(time - peak.timeSeconds) >= MOMENTS_MIN_MOMENT_SECONDS)) {
+            kept.push(peak.timeSeconds);
+        }
+    }
+    return kept.sort((left, right) => left - right).map(round);
+}
+function buildShot(id, startSeconds, endSeconds, samples) {
+    const motion = samples.length ? samples.reduce((sum, frame) => sum + frame.score, 0) / samples.length : 0;
+    return {
+        id,
+        startSeconds: round(startSeconds),
+        endSeconds: round(endSeconds),
+        motion: round(Math.min(1, motion)),
+        change: strongestChange(samples, startSeconds, endSeconds),
+    };
+}
+function strongestChange(samples, startSeconds, endSeconds) {
+    let best = null;
+    for (const frame of samples) {
+        if (frame.score < MOMENTS_CHANGE_THRESHOLD)
+            continue;
+        if (frame.timeSeconds - startSeconds < MOMENTS_MIN_MOMENT_SECONDS)
+            continue;
+        if (endSeconds - frame.timeSeconds < MOMENTS_MIN_MOMENT_SECONDS)
+            continue;
+        if (!best || frame.score > best.strength)
+            best = { timeSeconds: frame.timeSeconds, strength: frame.score };
+    }
+    return best ? {
+        timeSeconds: round(best.timeSeconds),
+        strength: round(best.strength),
+        quality: round(Math.min(1, best.strength / (2 * MOMENTS_SHOT_THRESHOLD))),
+    } : null;
+}
+export function usableRanges(ranges, shots) {
+    return ranges.map((range) => {
+        const inside = shots.filter((shot) => shot.startSeconds >= range.startSeconds && shot.endSeconds <= range.endSeconds + 0.001);
+        const start = inside.length && inside[0].startSeconds - range.startSeconds < MOMENTS_MIN_MOMENT_SECONDS
+            ? inside[0].endSeconds
+            : range.startSeconds;
+        const last = inside.at(-1);
+        const end = last && range.endSeconds - last.endSeconds < MOMENTS_MIN_MOMENT_SECONDS
+            ? last.startSeconds
+            : range.endSeconds;
+        return { startSeconds: round(start), endSeconds: round(end) };
+    }).filter((range) => range.endSeconds - range.startSeconds >= MOMENTS_MIN_MOMENT_SECONDS);
+}
+export function rankedMoments(shots) {
+    return shots
+        .filter((shot) => shot.endSeconds - shot.startSeconds >= MOMENTS_MIN_MOMENT_SECONDS)
+        .sort((left, right) => right.motion - left.motion || left.startSeconds - right.startSeconds)
+        .map((shot) => ({
+        shotId: shot.id,
+        startSeconds: shot.startSeconds,
+        endSeconds: shot.endSeconds,
+        score: shot.motion,
+        quality: round(Math.min(1, (shot.endSeconds - shot.startSeconds) / 2)),
+    }));
+}

package/dist/elevenlabs-audio-extension.js

@@ -0,0 +1,66 @@
+import { ElevenLabsSoundGenerationRequestSchema } from "@apicity/elevenlabs/zod";
+export const ELEVENLABS_SCRIBE_MODEL = "scribe_v2";
+export const ELEVENLABS_SOUND_EFFECT_MODEL = "eleven_text_to_sound_v2";
+export const ELEVENLABS_SOUND_EFFECT_OUTPUT_FORMAT = "mp3_44100_128";
+const AUDIO_CROSSFADE_MS = 500;
+export const MIN_AUDIO_CONTINUATION_MS = 500;
+export const MAX_AUDIO_CONTINUATION_MS = 29_500;
+// Derived from @apicity/elevenlabs@0.8.0 Sound Generation `.max(450)`.
+export const MAX_SOUND_GENERATION_PROMPT_CHARS = ElevenLabsSoundGenerationRequestSchema.shape.text.maxLength ?? 450;
+export const MAX_CONTINUATION_DIRECTION_CHARS = 250;
+const MAX_SOURCE_CONTEXT_CHARS = 100;
+const MIN_SOURCE_CONTEXT_CHARS = 20;
+export function normalizeContinuationPrompt(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return undefined;
+    const wrapped = /^\(([^()]*)\)$/.exec(trimmed);
+    const direction = (wrapped ? wrapped[1] : trimmed).trim();
+    return direction || undefined;
+}
+function transcriptText(response) {
+    if ("text" in response && typeof response.text === "string") {
+        return response.text;
+    }
+    if ("transcripts" in response && Array.isArray(response.transcripts)) {
+        return response.transcripts.map((transcript) => transcript.text).join(" ");
+    }
+    return "";
+}
+export function describeSourceAudio(response) {
+    const description = transcriptText(response)
+        .replace(/\[([^\]]+)\]/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+    return description.slice(0, 1_000) || "the same sound and ambient texture as the source audio";
+}
+export function buildSoundContinuationPrompt(sourceDescription, generationDurationSeconds, continuationPrompt) {
+    const duration = generationDurationSeconds.toFixed(1);
+    const direction = normalizeContinuationPrompt(continuationPrompt)
+        ?.slice(0, MAX_CONTINUATION_DIRECTION_CHARS)
+        .replace(/[.!?\s]+$/, "");
+    if (!direction) {
+        return [
+            `Continue this audio seamlessly for ${duration}s: ${sourceDescription.slice(0, MAX_SOURCE_CONTEXT_CHARS)}.`,
+            "Start immediately mid-action and match its character, setting, intensity, tone, and perspective.",
+            "Repeat or vary the source event naturally so matching sound fills the duration.",
+            "Keep matching activity and ambience audible through the final second.",
+            "No intro, unrelated sound, fade-in, early ending, or silent tail.",
+        ].join(" ").slice(0, MAX_SOUND_GENERATION_PROMPT_CHARS);
+    }
+    // Direction leads so the 450-char cap can only ever trim source context or
+    // closing guidance, never the user's requested change.
+    const lead = `Continue this audio for ${duration}s: ${direction}.`;
+    const close = "Transition smoothly from the source, follow the direction for the full duration, and keep it audible through the final second with no silent tail.";
+    const sourceLabel = "Source audio: ";
+    const sourceBudget = MAX_SOUND_GENERATION_PROMPT_CHARS
+        - lead.length - close.length - sourceLabel.length - " .".length - 1;
+    const source = sourceBudget >= MIN_SOURCE_CONTEXT_CHARS
+        ? sourceDescription.slice(0, Math.min(MAX_SOURCE_CONTEXT_CHARS, sourceBudget))
+        : "";
+    const context = source ? ` ${sourceLabel}${source}.` : "";
+    return `${lead}${context} ${close}`.slice(0, MAX_SOUND_GENERATION_PROMPT_CHARS);
+}
+export function audioCrossfadeMs(sourceDurationMs, continuationDurationMs) {
+    return Math.max(1, Math.min(AUDIO_CROSSFADE_MS, Math.floor(sourceDurationMs / 2), Math.floor(continuationDurationMs / 2)));
+}

package/dist/engine.js

@@ -0,0 +1,54 @@
+import { resolve } from "node:path";
+import { createEngine } from "videobook-engine";
+import { BookManager } from "./book-manager.js";
+import { scopedBookEngine } from "./book-context.js";
+import { contentStoreFromEnvironment } from "./content-store.js";
+import { dataLayout } from "./data-home.js";
+export function environmentValue(value, fallback) {
+    const normalized = value?.trim();
+    return normalized ? normalized : fallback;
+}
+function catalogBackupTemplate() {
+    const legacy = process.env.VIDEOBOOK_CATALOG_BACKUP_URL?.trim();
+    const template = process.env.VIDEOBOOK_CATALOG_BACKUP_URL_TEMPLATE?.trim();
+    if (legacy && !template) {
+        throw new Error("VIDEOBOOK_CATALOG_BACKUP_URL is not supported for multi-book storage; use VIDEOBOOK_CATALOG_BACKUP_URL_TEMPLATE with {bookId}");
+    }
+    if (template && !template.includes("{bookId}")) {
+        throw new Error("VIDEOBOOK_CATALOG_BACKUP_URL_TEMPLATE must include {bookId}");
+    }
+    return template || undefined;
+}
+const BOOK_LIBRARY_DIR = environmentValue(process.env.VIDEOBOOK_LIBRARY_DIR, dataLayout().libraryDir);
+const objectStore = contentStoreFromEnvironment();
+export const bookManager = new BookManager({
+    libraryDir: BOOK_LIBRARY_DIR,
+    ...(objectStore ? { remoteObjects: objectStore } : {}),
+    objectPrefix: environmentValue(process.env.VIDEOBOOK_OBJECT_PREFIX, "superlzy-media/videobook/sha256"),
+    catalogBackupName: environmentValue(process.env.VIDEOBOOK_CATALOG_BACKUP_NAME, "backup"),
+    ...(catalogBackupTemplate()
+        ? { catalogBackupUrlTemplate: catalogBackupTemplate() }
+        : {}),
+});
+export const scopedEngine = scopedBookEngine;
+const testEngines = new Map();
+export function createEngineForTest(rootDir) {
+    const normalizedRoot = resolve(rootDir);
+    const existing = testEngines.get(normalizedRoot);
+    if (existing)
+        return existing;
+    const engine = createEngine({
+        durableWrites: false,
+        rootDir: normalizedRoot,
+        initialBookName: "test-book",
+    });
+    testEngines.set(normalizedRoot, engine);
+    return engine;
+}
+export function closeEngineForTest(rootDir, engine) {
+    const normalizedRoot = resolve(rootDir);
+    if (testEngines.get(normalizedRoot) === engine) {
+        testEngines.delete(normalizedRoot);
+    }
+    engine.close();
+}

package/dist/env-file.js

@@ -0,0 +1,91 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { chmod, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { parse } from "dotenv";
+const KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const NEW_FILE_MODE = 0o600;
+const NEW_DIRECTORY_MODE = 0o700;
+function assignmentPattern(key) {
+    return new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`, "u");
+}
+export function hasControlCharacters(value) {
+    return [...value].some((character) => {
+        const code = character.codePointAt(0) ?? 0;
+        return code < 32 || code === 127;
+    });
+}
+export function formatEnvValue(value) {
+    if (!/[#'"\s]/u.test(value))
+        return value;
+    if (!value.includes("'"))
+        return `'${value}'`;
+    if (!value.includes("\""))
+        return `"${value}"`;
+    throw new Error("value cannot contain both single and double quotes");
+}
+function withoutAssignments(lines, key) {
+    const pattern = assignmentPattern(key);
+    return lines.filter((line) => !pattern.test(line));
+}
+function withAssignment(lines, key, value) {
+    const pattern = assignmentPattern(key);
+    const line = `${key}=${formatEnvValue(value)}`;
+    const last = lines.reduce((found, candidate, index) => pattern.test(candidate) ? index : found, -1);
+    if (last >= 0)
+        return lines.map((candidate, index) => index === last ? line : candidate);
+    return [...lines, line];
+}
+function splitLines(raw) {
+    if (raw === "")
+        return [];
+    const lines = raw.split("\n");
+    return lines.at(-1) === "" ? lines.slice(0, -1) : lines;
+}
+export function applyEnvUpdates(raw, updates) {
+    let lines = splitLines(raw);
+    for (const [key, value] of Object.entries(updates)) {
+        if (!KEY_PATTERN.test(key))
+            throw new Error(`${key} is not a valid environment variable name`);
+        lines = value === null ? withoutAssignments(lines, key) : withAssignment(lines, key, value);
+    }
+    return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+}
+export function readEnvValues(path) {
+    try {
+        return parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+async function readIfPresent(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function existingMode(path) {
+    try {
+        return (await stat(path)).mode & 0o777;
+    }
+    catch {
+        return NEW_FILE_MODE;
+    }
+}
+export async function updateEnvFile(path, updates) {
+    const raw = await readIfPresent(path);
+    const next = applyEnvUpdates(raw ?? "", updates);
+    await mkdir(dirname(path), { recursive: true, mode: NEW_DIRECTORY_MODE });
+    const mode = raw === null ? NEW_FILE_MODE : await existingMode(path);
+    const temporary = `${path}.tmp.${randomUUID()}`;
+    await writeFile(temporary, next, { encoding: "utf8", mode });
+    await chmod(temporary, mode);
+    await rename(temporary, path);
+}

package/dist/env-secrets.js

@@ -0,0 +1,148 @@
+/**
+ * Secret-source detection and .env editing.
+ *
+ * Secrets reach the server three ways:
+ *   1. `op run --env-file=.env.tpl --` resolves op:// references and injects
+ *      them into the environment BEFORE Node starts (npm run dev:server).
+ *   2. A plain `.env` file, loaded here with dotenv semantics: never override
+ *      a var that is already set, so op-injected values always win.
+ *   3. op:// references left in the environment or `.env`, plus the vault
+ *      named by VIDEOBOOK_OP_VAULT, resolved through the 1Password CLI by
+ *      resolveOnePassword() before a server starts.
+ *
+ * A managed key that was already set before `.env` loaded, or that 1Password
+ * resolved, is therefore "1password" — externally managed and read-only,
+ * because a `.env` write would be silently shadowed on the next start. A key
+ * whose literal value arrived via `.env` is "env" and editable. A
+ * shell-exported var is also classified "1password"; the label is
+ * approximate but the read-only behavior is right.
+ *
+ * `.env` lives in the data home (the repo root in a source checkout) and is
+ * server runtime configuration, not a project artifact, so direct node:fs is
+ * correct here — the videobook-engine rule covers managed artifacts and their
+ * materialized workspaces.
+ */
+import { dataLayout } from "./data-home.js";
+import { hasControlCharacters, readEnvValues, updateEnvFile } from "./env-file.js";
+import { resolveOnePasswordEnv } from "./one-password.js";
+export const MANAGED_ENV_KEYS = [
+    "OPENAI_API_KEY",
+    "KIE_API_KEY",
+    "XAI_API_KEY",
+    "X_CLIENT_ID",
+    "X_CLIENT_SECRET",
+    "DROPBOX_CLIENT_ID",
+    "DROPBOX_CLIENT_SECRET",
+    "KIMI_CODING_API_KEY",
+    "FAL_API_KEY",
+    "DASHSCOPE_API_KEY",
+    "ELEVENLABS_API_KEY",
+    "B2_ACCESS_KEY_ID",
+    "B2_SECRET_ACCESS_KEY",
+    "B2_REGION",
+    "B2_BUCKET",
+    "B2_ENDPOINT",
+    "B2_ARCHIVE_PREFIX",
+];
+const NON_SECRET_ENV_KEYS = new Set([
+    "B2_REGION",
+    "B2_BUCKET",
+    "B2_ENDPOINT",
+    "B2_ARCHIVE_PREFIX",
+]);
+function isManagedEnvKey(key) {
+    return MANAGED_ENV_KEYS.includes(key);
+}
+export function isSecretEnvKey(key) {
+    return !NON_SECRET_ENV_KEYS.has(key);
+}
+export function maskEnvValue(value) {
+    const prefixLength = Math.min(6, Math.max(2, value.length));
+    return `${value.slice(0, prefixLength)}${"*".repeat(8)}`;
+}
+/** Raised on rejected writes. Messages never include the secret value. */
+export class SecretWriteError extends Error {
+}
+function defaultEnvPath() {
+    return process.env.VIDEOBOOK_ENV_PATH ?? dataLayout().envPath;
+}
+export function createSecretStore(options = {}) {
+    const envPath = options.envPath ?? defaultEnvPath();
+    const processEnv = options.processEnv ?? process.env;
+    const preSet = new Set();
+    const fromOnePassword = new Set();
+    let loaded = false;
+    let resolution = null;
+    function loadDotenv() {
+        if (loaded)
+            return;
+        loaded = true;
+        for (const key of MANAGED_ENV_KEYS) {
+            const value = processEnv[key];
+            if (value !== undefined && value !== "")
+                preSet.add(key);
+        }
+        for (const [key, value] of Object.entries(readEnvValues(envPath))) {
+            if (processEnv[key] === undefined)
+                processEnv[key] = value;
+        }
+    }
+    function getValue(key) {
+        loadDotenv();
+        return processEnv[key];
+    }
+    function getSource(key) {
+        loadDotenv();
+        const value = processEnv[key];
+        if (!value || value.startsWith("op://"))
+            return "missing";
+        if (preSet.has(key) || fromOnePassword.has(key))
+            return "1password";
+        return "env";
+    }
+    async function setEnvSecret(key, rawValue) {
+        loadDotenv();
+        if (!isManagedEnvKey(key)) {
+            throw new SecretWriteError(`${String(key)} is not a managed environment key`);
+        }
+        const value = rawValue.trim();
+        if (!value)
+            throw new SecretWriteError(`${key} value is empty`);
+        if (hasControlCharacters(value)) {
+            throw new SecretWriteError(`${key} value contains control characters`);
+        }
+        if (getSource(key) === "1password") {
+            throw new SecretWriteError(`${key} is managed by 1Password; edit it in the vault`);
+        }
+        if (value.includes("'") && value.includes("\"")) {
+            throw new SecretWriteError("value cannot contain both single and double quotes");
+        }
+        await updateEnvFile(envPath, { [key]: value });
+        processEnv[key] = value;
+    }
+    function resolveOnePassword() {
+        if (resolution)
+            return resolution;
+        loadDotenv();
+        const resolved = resolveOnePasswordEnv(processEnv, MANAGED_ENV_KEYS);
+        for (const key of [...resolved.fromReferences, ...resolved.fromVault])
+            fromOnePassword.add(key);
+        resolution = resolved;
+        return resolved;
+    }
+    return {
+        loadDotenv,
+        getValue,
+        getSource,
+        setEnvSecret,
+        resolveOnePassword,
+        onePasswordResolution: () => resolution,
+        envPath: () => envPath,
+    };
+}
+let defaultStore = null;
+export function getDefaultSecretStore() {
+    if (!defaultStore)
+        defaultStore = createSecretStore();
+    return defaultStore;
+}

package/dist/ffmpeg-binary.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module";
+import { binaryRunsOnHost, readBinaryHeader } from "./ffprobe-binary.js";
+export function resolveFfmpegPath(bundledPath, override, hostArch) {
+    if (override)
+        return override;
+    if (!bundledPath)
+        return "ffmpeg";
+    const header = readBinaryHeader(bundledPath);
+    return header && binaryRunsOnHost(header, hostArch) ? bundledPath : "ffmpeg";
+}
+const require = createRequire(import.meta.url);
+export const FFMPEG = resolveFfmpegPath(require("ffmpeg-static"), process.env.VIDEOBOOK_FFMPEG_PATH, process.arch);