videobook 0.0.0-stage → 0.1.0

package/dist/cli/mcp-relay.js

@@ -0,0 +1,51 @@
+import { Client, ProtocolError, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { McpServer, fromJsonSchema, } from "@modelcontextprotocol/server";
+import { MCP_PROTOCOL_VERSION, SERVER_VERSION } from "../server.js";
+const RELAYED_CALL_TIMEOUT_MS = 30 * 60_000;
+async function listAllTools(client) {
+    const tools = [];
+    let cursor;
+    do {
+        const page = await client.listTools(cursor === undefined ? undefined : { cursor });
+        tools.push(...page.tools);
+        cursor = page.nextCursor;
+    } while (cursor !== undefined);
+    return tools;
+}
+export async function connectUpstream(mcpUrl) {
+    const client = new Client({ name: "videobook-mcp-relay", version: SERVER_VERSION }, {
+        capabilities: {},
+        supportedProtocolVersions: [MCP_PROTOCOL_VERSION],
+        versionNegotiation: { mode: { pin: MCP_PROTOCOL_VERSION } },
+    });
+    await client.connect(new StreamableHTTPClientTransport(new URL(mcpUrl)));
+    return { url: mcpUrl, client, tools: await listAllTools(client), close: () => client.close() };
+}
+function relayFailure(url, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const text = error instanceof ProtocolError
+        ? reason
+        : `The videobook server at ${url} did not answer (${reason}). Restart it or restart videobook mcp.`;
+    return { isError: true, content: [{ type: "text", text }] };
+}
+function registerRelayedTool(server, upstream, tool) {
+    server.registerTool(tool.name, {
+        ...(tool.title ? { title: tool.title } : {}),
+        ...(tool.description ? { description: tool.description } : {}),
+        ...(tool.annotations ? { annotations: tool.annotations } : {}),
+        inputSchema: fromJsonSchema(tool.inputSchema),
+    }, async (args, ctx) => {
+        try {
+            return await upstream.client.callTool({ name: tool.name, arguments: args }, { timeout: RELAYED_CALL_TIMEOUT_MS, signal: ctx.mcpReq.signal });
+        }
+        catch (error) {
+            return relayFailure(upstream.url, error);
+        }
+    });
+}
+export function createRelayServer(upstream, instructions) {
+    const server = new McpServer({ name: "videobook", version: SERVER_VERSION }, { instructions });
+    for (const tool of upstream.tools)
+        registerRelayedTool(server, upstream, tool);
+    return server;
+}

package/dist/cli/open-browser.js

@@ -0,0 +1,14 @@
+import { spawn } from "node:child_process";
+function browserCommand(url, platform) {
+    if (platform === "darwin")
+        return { command: "open", args: [url] };
+    if (platform === "win32")
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    return { command: "xdg-open", args: [url] };
+}
+export function openInBrowser(url, platform = process.platform) {
+    const { command, args } = browserCommand(url, platform);
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => undefined);
+    child.unref();
+}

package/dist/cli/run-command.js

@@ -0,0 +1,187 @@
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { z } from "zod";
+import { gcLibraryCatalogs } from "../catalog-gc.js";
+import { bookManager, scopedEngine } from "../engine.js";
+import { waitForJob } from "../queue.js";
+import { MCP_PROTOCOL_VERSION, SERVER_VERSION } from "../server.js";
+import { inspectServerOwner } from "../server-lock.js";
+import { startServer } from "../serve.js";
+import { getAllToolDefs } from "../tools/index.js";
+const REQUEST_GRACE_MS = 60_000;
+function newClient() {
+    return new Client({ name: "videobook-cli", version: SERVER_VERSION }, {
+        capabilities: {},
+        supportedProtocolVersions: [MCP_PROTOCOL_VERSION],
+        versionNegotiation: { mode: { pin: MCP_PROTOCOL_VERSION } },
+    });
+}
+async function connect(mcpUrl) {
+    const client = newClient();
+    await client.connect(new StreamableHTTPClientTransport(new URL(mcpUrl)));
+    return client;
+}
+function refuseUnresponsive(owner) {
+    if (owner.kind !== "unresponsive")
+        return;
+    throw new Error(`videobook (pid ${owner.record.pid}) holds ${bookManager.rootDir} but is not responding. Stop it first.`);
+}
+async function temporaryOwner() {
+    const running = await startServer({ port: 0, ui: false });
+    await running.ready;
+    const client = await connect(running.mcpUrl);
+    return {
+        client,
+        temporary: true,
+        async close() {
+            await client.close();
+            await running.close();
+        },
+    };
+}
+async function openOwnerSession() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    refuseUnresponsive(owner);
+    if (owner.kind !== "running")
+        return temporaryOwner();
+    const client = await connect(`${owner.record.url}/mcp`);
+    return { client, temporary: false, close: () => client.close() };
+}
+function textOf(result) {
+    return result.content.flatMap((item) => item.type === "text" ? [item.text] : [JSON.stringify(item)]);
+}
+function parseJsonObject(text) {
+    if (!text)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" && value !== "" ? value : null;
+}
+async function waitInProcess(jobId, timeoutSeconds) {
+    process.stderr.write(`Waiting for job ${jobId}...\n`);
+    try {
+        await waitForJob(jobId, timeoutSeconds * 1000);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    process.stderr.write(`Job ${jobId} completed.\n`);
+    return 0;
+}
+async function waitForAsset(client, bookId, assetId, timeoutSeconds) {
+    process.stderr.write(`Waiting for asset ${assetId}...\n`);
+    const result = await client.callTool({ name: "wait_for_asset_ready", arguments: { book_id: bookId, asset_id: assetId, timeout_seconds: timeoutSeconds } }, { timeout: timeoutSeconds * 1000 + REQUEST_GRACE_MS });
+    for (const line of textOf(result))
+        process.stdout.write(`${line}\n`);
+    return result.isError ? 1 : 0;
+}
+async function waitForOutcome(session, flags, args, first) {
+    const jobId = stringField(first, "job_id");
+    const assetId = stringField(first, "asset_id");
+    const bookId = typeof args.book_id === "string" ? args.book_id : null;
+    if (session.temporary && jobId)
+        return waitInProcess(jobId, flags.timeoutSeconds);
+    if (!flags.wait || !jobId)
+        return 0;
+    if (assetId && bookId)
+        return waitForAsset(session.client, bookId, assetId, flags.timeoutSeconds);
+    process.stderr.write(`Job ${jobId} is queued on the running server; follow it with list_jobs.\n`);
+    return 0;
+}
+async function callOnce(session, flags, tool, args) {
+    try {
+        return await session.client.callTool({ name: tool, arguments: args }, { timeout: flags.timeoutSeconds * 1000 + REQUEST_GRACE_MS });
+    }
+    catch (error) {
+        process.stderr.write(`videobook run: ${error instanceof Error ? error.message : String(error)}\n`);
+        return null;
+    }
+}
+export async function runToolCommand(flags, tool, args) {
+    const session = await openOwnerSession();
+    try {
+        const result = await callOnce(session, flags, tool, args);
+        if (!result)
+            return 1;
+        const lines = textOf(result);
+        const stream = result.isError ? process.stderr : process.stdout;
+        for (const line of lines)
+            stream.write(`${line}\n`);
+        if (result.isError)
+            return 1;
+        return await waitForOutcome(session, flags, args, parseJsonObject(lines[0]));
+    }
+    finally {
+        await session.close();
+    }
+}
+function listingFromJsonSchema(tool) {
+    const properties = Object.keys(tool.inputSchema.properties ?? {});
+    const required = new Set(tool.inputSchema.required ?? []);
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        required: properties.filter((key) => required.has(key)),
+        optional: properties.filter((key) => !required.has(key)),
+    };
+}
+function localListings() {
+    return getAllToolDefs(scopedEngine, bookManager).map((def) => {
+        const schema = z.object(def.schema).toJSONSchema();
+        const required = new Set(schema.required ?? []);
+        const keys = Object.keys(def.schema);
+        return {
+            name: def.name,
+            ...(def.description ? { description: def.description } : {}),
+            required: keys.filter((key) => required.has(key)),
+            optional: keys.filter((key) => !required.has(key)),
+        };
+    });
+}
+async function ownerListings(owner) {
+    if (owner.kind !== "running")
+        return null;
+    const client = await connect(`${owner.record.url}/mcp`);
+    try {
+        return (await client.listTools()).tools.map(listingFromJsonSchema);
+    }
+    finally {
+        await client.close();
+    }
+}
+function renderListing(listing) {
+    const params = [...listing.required.map((key) => `<${key}>`), ...listing.optional.map((key) => `[${key}]`)].join(" ");
+    const head = params ? `${listing.name} ${params}` : listing.name;
+    return listing.description ? `${head}\n    ${listing.description}` : head;
+}
+export async function runToolsCommand() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    refuseUnresponsive(owner);
+    const listings = await ownerListings(owner) ?? localListings();
+    for (const listing of listings)
+        process.stdout.write(`${renderListing(listing)}\n`);
+    return 0;
+}
+export async function runGcBooksCommand() {
+    const owner = await inspectServerOwner(bookManager.rootDir);
+    if (owner.kind !== "none") {
+        process.stderr.write(`videobook is running at ${owner.record.url} (pid ${owner.record.pid}); stop it before collecting catalog garbage.\n`);
+        return 1;
+    }
+    try {
+        const reports = await gcLibraryCatalogs(bookManager);
+        process.stdout.write(`${JSON.stringify({ catalogs: reports }, null, 2)}\n`);
+        return 0;
+    }
+    finally {
+        await bookManager.close();
+    }
+}

package/dist/cli/serve-command.js

@@ -0,0 +1,57 @@
+import { resolvePort } from "./args.js";
+import { openInBrowser } from "./open-browser.js";
+import { logger } from "../logger.js";
+import { SERVER_VERSION } from "../server.js";
+import { ServerAlreadyRunningError } from "../server-lock.js";
+import { installSignalHandlers, startServer } from "../serve.js";
+function uiLine(running) {
+    if (running.uiStatus === "served")
+        return `${running.url}/`;
+    if (running.uiStatus === "disabled")
+        return "off (--headless)";
+    return `not built at ${running.uiDir}; serving MCP and API only`;
+}
+function printBanner(running) {
+    process.stdout.write([
+        `videobook ${SERVER_VERSION}`,
+        `Library  ${running.libraryDir}`,
+        `UI       ${uiLine(running)}`,
+        `MCP      ${running.mcpUrl}`,
+        "Agents   claude mcp add videobook -- videobook mcp",
+        "",
+    ].join("\n"));
+}
+function reportStartupFailure(error, port) {
+    if (error instanceof ServerAlreadyRunningError) {
+        process.stderr.write(`${error.message}\n`);
+        return 1;
+    }
+    logger.error("startup-failed", { error, port });
+    if (error?.code === "EADDRINUSE") {
+        process.stderr.write(`Port ${port} is already in use by another process; pass --port <n>.\n`);
+    }
+    return 1;
+}
+function hydrationFailure(running) {
+    return running.ready.then(() => new Promise(() => undefined), async (error) => {
+        logger.error("startup-failed", { error, port: running.port });
+        await running.close().catch(() => undefined);
+        return 1;
+    });
+}
+export async function runServeCommand(flags) {
+    const port = resolvePort(process.env);
+    const starting = startServer({ port, ui: flags.ui });
+    const stopped = new Promise((resolveStop) => installSignalHandlers(starting, resolveStop));
+    let running;
+    try {
+        running = await starting;
+    }
+    catch (error) {
+        return reportStartupFailure(error, port);
+    }
+    printBanner(running);
+    if (flags.open && running.uiStatus === "served")
+        openInBrowser(`${running.url}/`);
+    return Promise.race([stopped, hydrationFailure(running)]);
+}

package/dist/cli/stdio-guard.js

@@ -0,0 +1,8 @@
+import { Console } from "node:console";
+export function redirectConsoleToStderr() {
+    Object.defineProperty(globalThis, "console", {
+        value: new Console({ stdout: process.stderr, stderr: process.stderr }),
+        writable: true,
+        configurable: true,
+    });
+}

package/dist/cold-open-model.js

@@ -0,0 +1,7 @@
+export function coldOpenRangeError(start, end, duration) {
+    if (![start, end, duration].every(Number.isFinite) || duration < 0.5)
+        return "Choose a playable video at least 0.5 seconds long.";
+    if (start < 0 || end > duration || end - start < 0.5 - 0.000001)
+        return "Choose a highlight at least 0.5 seconds long within the video.";
+    return null;
+}

package/dist/cold-open.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { findPrimaryMediaFile } from "videobook-engine";
+import { notebookGridTag, notebookOccupiedSlots, NOTEBOOK_GRID_ROW_COUNT, NOTEBOOK_GRID_COLUMN_COUNT } from "videobook-engine/notebook-grid";
+import { z } from "zod";
+import { INTELLIGENCE_MODEL } from "./openai-intelligence.js";
+import { coldOpenRangeError } from "./cold-open-model.js";
+const coldOpenSuggestionSchema = z.object({
+    sourceArtifactId: z.string().uuid(),
+    sourceObjectHash: z.string().min(1),
+    durationSeconds: z.number().finite().min(0.5),
+    fps: z.number().finite().positive(),
+    startSeconds: z.number().finite().nonnegative(),
+    endSeconds: z.number().finite().positive(),
+    reason: z.string().min(1),
+    model: z.string().min(1),
+});
+export async function coldOpenSource(engine, artifactId, expectedHash) {
+    const artifact = engine.artifacts.get(artifactId);
+    if (!artifact.ok)
+        throw new Error(artifact.error.message);
+    if (!["video", "final"].includes(artifact.value.kind))
+        throw new Error("Choose a video for the cold open.");
+    const manifest = await engine.files.manifest(artifactId, { includeDotfiles: true });
+    if (!manifest.ok)
+        throw new Error(manifest.error.message);
+    const file = findPrimaryMediaFile(manifest.value.files, artifact.value.kind);
+    if (!file)
+        throw new Error("The source video is missing.");
+    if (expectedHash && file.objectHash !== expectedHash)
+        throw new Error("The source video changed. Open a new cold-open review.");
+    const streams = engine.streams.list(artifactId);
+    if (!streams.ok)
+        throw new Error(streams.error.message);
+    const video = streams.value.find(stream => stream.kind === "video" && stream.sourcePath === file.name && stream.objectHash === file.objectHash);
+    if (!video)
+        throw new Error("Wait for the video to finish processing before making a cold open.");
+    const durationSeconds = video.durationTicks * video.timeBase.numerator / video.timeBase.denominator;
+    const metadata = await engine.metadata.artifacts.read(artifactId, "original");
+    const fps = metadata.ok && metadata.value.fps && metadata.value.fps > 0 ? metadata.value.fps : 30;
+    const error = coldOpenRangeError(0, durationSeconds, durationSeconds);
+    if (error)
+        throw new Error(error);
+    return { artifact: artifact.value, file, manifest: manifest.value, path: join(manifest.value.path, file.name), durationSeconds, fps };
+}
+export function coldOpenCacheKey(source) {
+    const inputs = source.manifest.files.filter(file => ["elevenlabs.json", ".analysis.gpt4otrans.json"].includes(file.name))
+        .map(file => [file.name, file.objectHash]).sort();
+    return `cold-open.suggestion.${createHash("sha256").update(JSON.stringify([1, INTELLIGENCE_MODEL, source.artifact.artifactId, source.file.objectHash, inputs])).digest("hex")}`;
+}
+export function readColdOpenSuggestion(engine, key) {
+    const parsed = coldOpenSuggestionSchema.safeParse(engine.settings.get(key));
+    if (!parsed.success || coldOpenRangeError(parsed.data.startSeconds, parsed.data.endSeconds, parsed.data.durationSeconds))
+        return null;
+    return parsed.data;
+}
+export function coldOpenDestination(notebook, sourceArtifactId) {
+    const occupied = new Set(notebookOccupiedSlots(notebook.cells).map(notebookGridTag));
+    const source = notebook.cells.find(cell => cell.outputArtifactId === sourceArtifactId);
+    const below = source ? { row: source.slot.row + 1, column: source.slot.column } : null;
+    if (below && below.row < NOTEBOOK_GRID_ROW_COUNT && !occupied.has(notebookGridTag(below)))
+        return below;
+    for (let row = 0; row < NOTEBOOK_GRID_ROW_COUNT; row += 1) {
+        for (let column = 0; column < NOTEBOOK_GRID_COLUMN_COUNT; column += 1) {
+            const slot = { row, column };
+            if (!occupied.has(notebookGridTag(slot)))
+                return slot;
+        }
+    }
+    throw new Error("The notebook needs one empty cell for the cold-open copy.");
+}
+export function checkColdOpenNotebook(engine, notebookId, sourceArtifactId) {
+    if (!notebookId)
+        return;
+    const notebook = engine.notebooks.read(notebookId);
+    if (!notebook.ok)
+        throw new Error(notebook.error.message);
+    coldOpenDestination(notebook.value, sourceArtifactId);
+}

package/dist/command-reference.js

@@ -0,0 +1,95 @@
+import { listModels } from "./media/listing.js";
+import { buildWorkspaceActionCatalog } from "./workspace-action-catalog.js";
+import { WORKSPACE_ACTION_SURFACES } from "./workspace-action-surfaces.js";
+function oneLine(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function escapeTable(value) {
+    return oneLine(value).replaceAll("|", "\\|");
+}
+export function renderCommandReference(tools, commands) {
+    const toolLines = [...tools]
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((tool) => `- \`${tool.name}\` — ${oneLine(tool.description)}`);
+    const catalog = buildWorkspaceActionCatalog(tools, commands);
+    const commandLines = [...catalog.actions]
+        .sort((a, b) => a.command.localeCompare(b.command))
+        .map((command) => {
+        const aliases = command.aliases ?? [];
+        const aliasText = aliases.length > 0 ? ` (aliases: ${aliases.map((alias) => `\`${alias}\``).join(", ")})` : "";
+        const target = command.handler.kind === "tool"
+            ? `; MCP: \`${command.handler.tool}\``
+            : command.handler.kind === "ui" ? `; UI: \`${command.handler.action}\`` : "; preview or workspace operation";
+        return `- \`${command.command}\`${aliasText} — ${oneLine(command.description)}${target}`;
+    });
+    return `# Command Reference
+
+Every current MCP endpoint and discoverable action is listed once. Use the Actions button on any screen, press Ctrl+Shift+K / Cmd+Shift+K, or type a slash in chat to browse the complete catalog. Search includes aliases and descriptions. A command with missing arguments opens its form; media, notebook, entity, track and clip selectors provide targets. Advanced provider alternatives retain shared input fields and show a cost review before generation.
+
+Media commands \`/export\`, \`/delete\`, \`/reverse\` and \`/trim\` target media. Sequence operations use \`/export-sequence\`, \`/clip-delete\`, \`/clip-reverse\`, \`/clip-trim\`, and \`/clip-audio\`; clip timing uses frames and media trimming uses seconds. \`/clip-audio\` edits gain, mute, and fades on an audio-track clip. Explicit legacy clip IDs and \`/export @sequence-main\` remain accepted. Use grid addresses such as \`/crop @a1\`, \`/trim @a1 0 2\` or \`/insert @a1 0 60\`.
+
+Image, video and audio generation runs through \`generate_image\`, \`generate_video\` and \`generate_audio\` with a model id from \`list_generation_models\`; see [generation-models.md](generation-models.md). Slash aliases match their canonical action in search. The legacy \`/skeleton\` shortcut opens a reviewed AI pose-guide request. Import owns upload transport and duplicate-byte checks; it uses a native file picker. Set \`VIDEOBOOK_DOWNLOADS_DIR\` to override the server's default Downloads directory.
+
+Routine pointer actions return focus to chat. Editing fields, open dialogs, keyboard navigation and native playback retain focus. Closing a dialog restores its opener when appropriate; delayed work cannot take focus from a newer edit.
+
+## MCP endpoints (${tools.length})
+
+${toolLines.join("\n")}
+
+## Slash actions (${catalog.actions.length}; ${commands.length} dedicated command routes)
+
+${commandLines.join("\n")}
+- \`/<project-name>\` — Switch to that project; generated dynamically for each project whose name does not conflict with a command or alias.
+`;
+}
+export function renderWorkspaceActionCoverage(catalog) {
+    const rows = [...catalog.actions].sort((left, right) => left.id.localeCompare(right.id)).map((action) => {
+        const target = action.target.argument ? `${action.target.kind}${action.target.multiple ? " selection" : ""}: ${action.target.argument}` : action.target.kind;
+        const handler = action.handler.kind === "tool" ? action.handler.tool : action.handler.kind === "ui" ? action.handler.action : action.handler.command;
+        return `| \`${action.id}\` | \`${action.command}\` | ${action.aliases.join(", ")} | ${action.scope} | ${escapeTable(target)} | \`${handler}\` | ${action.surfaces.join(", ")} | ${action.focus} | ${action.confirmation} |`;
+    });
+    const surfaces = Object.entries(WORKSPACE_ACTION_SURFACES).map(([name, entry]) => `| ${name} | [${entry.component}](../${entry.component}) | ${entry.trigger} |`);
+    const workflows = catalog.tools.filter((entry) => entry.exposure === "workflow").map((entry) => `| \`${entry.tool}\` | \`${entry.actionId}\` | ${escapeTable(entry.reason)} |`);
+    return `# Workspace action coverage
+
+Generated by \`npm run docs:commands\` from the registered tools, command definitions and surface contracts. ${catalog.tools.length} active endpoints map to ${catalog.actions.length} visible actions or their owning workflows. Unknown endpoints, handlers, aliases and missing declared surfaces fail the catalog contract.
+
+The browser regression suite checks catalog equality, complete slash traversal, typed form discovery, named target selection, menu and slash parity, review and cancellation, real media mutations and focus. Provider generation, posting and OS clipboard integration require separate execution validation; opening a form never starts a paid job or publishes content.
+
+## Surface entry points
+
+| Surface | Component | Entry point |
+| --- | --- | --- |
+${surfaces.join("\n")}
+
+## Actions
+
+| Stable ID | Command | Aliases | Scope | Target | Handler | Surfaces | Focus | Review |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+${rows.join("\n")}
+
+## Transport and workflow ownership
+
+| Endpoint | Visible owner | Reason |
+| --- | --- | --- |
+${workflows.join("\n")}
+`;
+}
+export function renderGenerationModels() {
+    const models = listModels({ includeHidden: true });
+    const rows = models.map((model) => {
+        const refs = model.slots.map((slot) => `${slot.role} ${slot.min}-${slot.max ?? "n"}`).join(", ") || "none";
+        const modes = model.modes.length > 1 ? model.modes.map((mode) => mode.id).join(", ") : "";
+        return `| \`${escapeTable(model.id)}\` | ${escapeTable(model.title)} | ${model.media} | ${model.entry.operations.join(", ")} | ${escapeTable(refs)} | ${modes} | ${model.entry.hidden ? "hidden" : "visible"} |`;
+    });
+    return `# Generation Models
+
+Generated by \`npm run docs:commands\` from the media catalog (\`server/src/media/catalog.ts\`). Call \`generate_image\`, \`generate_video\` or \`generate_audio\` with one of these model ids; \`list_generation_models\` returns the same list with every option, enum, range and default read from the apicity schemas.
+
+- Models: ${models.length}
+
+| Model | Title | Media | Operations | Refs | Modes | Picker |
+| --- | --- | --- | --- | --- | --- | --- |
+${rows.join("\n")}
+`;
+}

package/dist/content-store.js

@@ -0,0 +1,74 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { B2Error, createB2 } from "@apicity/b2";
+function createB2ContentStore(config) {
+    const provider = createB2({
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        region: config.region,
+        ...(config.endpoint ? { endpoint: config.endpoint } : {}),
+    });
+    return {
+        head: async (key) => {
+            try {
+                const result = await provider.objects.head({
+                    bucket: config.bucket,
+                    key,
+                });
+                return {
+                    exists: true,
+                    ...(result.contentLength !== undefined
+                        ? { size: result.contentLength }
+                        : {}),
+                };
+            }
+            catch (error) {
+                if (error instanceof B2Error && error.status === 404) {
+                    return { exists: false };
+                }
+                throw error;
+            }
+        },
+        uploadFile: async (key, sourcePath) => {
+            await provider.objects.put({
+                bucket: config.bucket,
+                key,
+                body: await readFile(sourcePath),
+                contentType: "application/octet-stream",
+            });
+        },
+        downloadFile: async (key, destinationPath) => {
+            const result = await provider.objects.get({
+                bucket: config.bucket,
+                key,
+            });
+            await writeFile(destinationPath, new Uint8Array(result.body));
+        },
+        delete: async (key) => {
+            await provider.objects.del({
+                bucket: config.bucket,
+                key,
+            });
+        },
+    };
+}
+export function b2ContentStoreConfigFromEnvironment() {
+    const accessKeyId = process.env.B2_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.B2_SECRET_ACCESS_KEY;
+    const region = process.env.B2_REGION;
+    const bucket = process.env.B2_BUCKET;
+    if (!accessKeyId || !secretAccessKey || !region || !bucket)
+        return undefined;
+    return {
+        accessKeyId,
+        secretAccessKey,
+        region,
+        bucket,
+        ...(process.env.B2_ENDPOINT
+            ? { endpoint: process.env.B2_ENDPOINT }
+            : {}),
+    };
+}
+export function contentStoreFromEnvironment() {
+    const config = b2ContentStoreConfigFromEnvironment();
+    return config ? createB2ContentStore(config) : undefined;
+}

package/dist/cost.js

@@ -0,0 +1,8 @@
+import { createCost } from "@apicity/cost";
+let cached = null;
+export function getCostProvider() {
+    if (cached)
+        return cached;
+    cached = createCost();
+    return cached;
+}

package/dist/crop-geometry.js

@@ -0,0 +1,23 @@
+const CANONICAL_DIMS = {
+    "16:9": [1920, 1080],
+    "9:16": [1080, 1920],
+    "1:1": [1080, 1080],
+};
+export function cropGeometry(rect, srcW, srcH, ratio, alignment) {
+    if (!Number.isFinite(srcW) || !Number.isFinite(srcH) || srcW < alignment || srcH < alignment) {
+        throw new Error("Could not probe usable source dimensions");
+    }
+    const cropW = Math.min(Math.floor(srcW / alignment) * alignment, Math.max(alignment, Math.round(rect.w * srcW / alignment) * alignment));
+    const cropH = Math.min(Math.floor(srcH / alignment) * alignment, Math.max(alignment, Math.round(rect.h * srcH / alignment) * alignment));
+    const roundOrigin = alignment === 2 ? Math.floor : Math.round;
+    const cropX = Math.min(srcW - cropW, Math.max(0, roundOrigin(rect.x * srcW / alignment) * alignment));
+    const cropY = Math.min(srcH - cropH, Math.max(0, roundOrigin(rect.y * srcH / alignment) * alignment));
+    const [outW, outH] = CANONICAL_DIMS[ratio];
+    const cropAspect = cropW / cropH;
+    const targetAspect = outW / outH;
+    const aspectError = Math.abs(cropAspect - targetAspect) / targetAspect;
+    if (aspectError > 0.02) {
+        throw new Error(`Crop rectangle aspect ${cropAspect.toFixed(4)} (${cropW}x${cropH}) does not match target ratio ${ratio} (${targetAspect.toFixed(4)}); error ${(aspectError * 100).toFixed(1)}% > 2%`);
+    }
+    return { cropX, cropY, cropW, cropH, outW, outH };
+}