videobook 0.2.5 → 0.3.1

package/dist/generation-har.js

@@ -0,0 +1,106 @@
+import { scrubHar } from "@apicity/har";
+import { captureFileExists, captureFilePath, readCaptureFile, readHarIndex } from "./har-index.js";
+import { harDirectory } from "./har-settings.js";
+import { readProviderTaskRecord } from "./provider-task-record.js";
+function bookIdOf(engine) {
+    try {
+        return engine.book.get().bookId;
+    }
+    catch {
+        return null;
+    }
+}
+export async function captureKeys(engine, ids) {
+    const known = new Set([...ids].filter((id) => typeof id === "string" && id.length > 0));
+    const taskIds = new Set();
+    for (const id of known) {
+        const task = await readProviderTaskRecord(engine, id).catch(() => null);
+        if (task && task.taskId !== "queued")
+            taskIds.add(task.taskId);
+    }
+    return { bookId: bookIdOf(engine), ids: known, taskIds };
+}
+export async function generationCaptureKeys(engine, generationId) {
+    let generation = null;
+    try {
+        generation = engine.generations.read(generationId);
+    }
+    catch {
+        generation = null;
+    }
+    const row = generation?.ok ? generation.value : null;
+    return captureKeys(engine, [generationId, row?.providerArtifactId, row?.outputArtifactId]);
+}
+function matchesCapture(row, keys) {
+    const context = row.context ?? {};
+    if (keys.bookId && typeof context.bookId === "string" && context.bookId !== keys.bookId)
+        return false;
+    return [context.artifactId, context.attemptId].some((id) => typeof id === "string" && keys.ids.has(id))
+        || (typeof context.providerTaskId === "string" && keys.taskIds.has(context.providerTaskId));
+}
+function chronological(a, b) {
+    return a.ts.localeCompare(b.ts) || a.callId.localeCompare(b.callId);
+}
+async function attemptCaptureRows(keys, rows, dir = harDirectory()) {
+    const matched = (rows ?? await readHarIndex(dir)).filter((row) => matchesCapture(row, keys)).sort(chronological);
+    const present = await Promise.all(matched.map((row) => captureFileExists(dir, row.file)));
+    return matched.filter((_row, index) => present[index]);
+}
+export async function generationHarStatus(keys, mode, rows, dir = harDirectory()) {
+    const captures = await attemptCaptureRows(keys, rows, dir);
+    const primary = [...captures].reverse().find((row) => row.outcome !== "ok") ?? captures.at(-1);
+    return {
+        mode,
+        hasCapture: captures.length > 0,
+        captures: captures.length,
+        path: primary ? captureFilePath(dir, primary.file) : null,
+        outcome: primary?.outcome ?? null,
+    };
+}
+function combineCaptures(captures, generationId) {
+    const [first] = captures;
+    if (!first || captures.length === 1)
+        return first?.har ?? null;
+    const pages = captures.map(({ row, har }) => ({
+        startedDateTime: har.log._apicity?.startedAt ?? row.ts,
+        id: har.log._apicity?.callId ?? row.callId,
+        title: `${row.provider} ${row.endpoint} (${row.outcome})`,
+        pageTimings: {},
+        ...(har.log._apicity ? { _apicity: har.log._apicity } : {}),
+    }));
+    return {
+        log: {
+            version: "1.2",
+            creator: first.har.log.creator,
+            comment: `videobook generation ${generationId}: ${captures.length} captured apicity calls, one page each`,
+            pages,
+            entries: captures.flatMap(({ row, har }) => har.log.entries.map((entry) => ({
+                ...entry,
+                pageref: har.log._apicity?.callId ?? row.callId,
+            }))),
+        },
+    };
+}
+export async function generationHar(keys, generationId, dir = harDirectory()) {
+    const loaded = [];
+    for (const row of await attemptCaptureRows(keys, undefined, dir)) {
+        const capture = await readCaptureFile(dir, row.file);
+        if (capture)
+            loaded.push({ row, path: capture.path, har: scrubHar(capture.har) });
+    }
+    const har = combineCaptures(loaded, generationId);
+    if (!har)
+        return null;
+    return {
+        captures: loaded.map(({ row, path }) => ({
+            path,
+            ts: row.ts,
+            callId: row.callId,
+            provider: row.provider,
+            endpoint: row.endpoint,
+            outcome: row.outcome,
+            status: row.status ?? null,
+        })),
+        har,
+    };
+}

package/dist/generation-reference-mentions.js

@@ -65,6 +65,25 @@ export function rewriteSeedanceAssetMentions(prompt, refs) {
     }
     return replaceNotebookMentions(prompt, replacements);
 }
+function numberedMentions(refs, marker) {
+    return refMentionEntries(refs).map(({ ref, index }) => ({
+        reference: ref,
+        replacement: `@${marker}_${index + 1}`,
+    }));
+}
+export function rewriteKling4ReferenceMentions(prompt, imageRefs, videoRefs) {
+    return replaceNotebookMentions(prompt, [
+        ...numberedMentions(imageRefs, "image"),
+        ...numberedMentions(videoRefs, "video"),
+    ]);
+}
+export function rewriteKling4FrameMentions(prompt, frames) {
+    return replaceNotebookMentions(prompt, [
+        ...frames.first.slice(0, 1).map((reference) => ({ reference, replacement: "@first_frame" })),
+        ...numberedMentions(frames.keyframes, "keyframe"),
+        ...frames.last.slice(0, 1).map((reference) => ({ reference, replacement: "@last_frame" })),
+    ]);
+}
 export function rewriteViduReferenceMentions(prompt, imageRefs, audioRefs) {
     return replaceNotebookMentions(prompt, [
         ...refMentionEntries(imageRefs).map(({ ref, index }) => ({

package/dist/goal-plan-v3.js

@@ -4,6 +4,8 @@ import { goalPromptWords } from "./goal-prompt-budget.js";
 import { LIGHTNING_COLD_OPEN_SECONDS, LIGHTNING_SCENE_ASPECT_RATIO, LIGHTNING_SCENE_MODEL, LIGHTNING_SCENE_OUTPUT_FORMAT, LIGHTNING_SCENE_PROMPT_WORDS, LIGHTNING_SCENE_RESOLUTION, LIGHTNING_VIDEO_DURATION_SECONDS, LIGHTNING_VIDEO_GENERATE_AUDIO, LIGHTNING_VIDEO_OUTPUT_FORMAT, LIGHTNING_VIDEO_PROMPT_WORDS, LIGHTNING_VIDEO_RESOLUTION, LIGHTNING_VIDEO_MODEL, LIGHTNING_WATERMARK_PROFILE, preservedPrompt, } from "./lightning-defaults.js";
 const IMAGE_LIMIT = 30;
 const VIDEO_LIMIT = 10;
+const LEGACY_SCENE_RESOLUTION = "2K";
+const SCENE_RESOLUTIONS = [LEGACY_SCENE_RESOLUTION, "4K"];
 export const goalMediaRefSchema = z.object({
     kind: z.enum(["image", "video"]),
     artifactId: z.string().min(1),
@@ -22,7 +24,7 @@ export const goalPlanV3Schema = z.object({
         tool: z.literal("generate_image"),
         model: z.literal(LIGHTNING_SCENE_MODEL),
         aspectRatio: z.enum(["16:9", "9:16", "1:1"]),
-        resolution: z.literal(LIGHTNING_SCENE_RESOLUTION),
+        resolution: z.enum(SCENE_RESOLUTIONS),
         outputFormat: z.literal(LIGHTNING_SCENE_OUTPUT_FORMAT),
         imageRefs: z.array(goalMediaRefSchema).max(IMAGE_LIMIT),
     }).strict(),
@@ -59,6 +61,14 @@ export const goalPlanV3Schema = z.object({
         }).strict(),
     }).strict(),
 }).strict();
+function withLegacySceneResolution(plan) {
+    if (typeof plan !== "object" || plan === null || !("version" in plan) || plan.version !== 3)
+        return plan;
+    if (!("scene" in plan) || typeof plan.scene !== "object" || plan.scene === null || "resolution" in plan.scene)
+        return plan;
+    return { ...plan, scene: { ...plan.scene, resolution: LEGACY_SCENE_RESOLUTION } };
+}
+export const savedGoalPlanV3Schema = z.preprocess(withLegacySceneResolution, goalPlanV3Schema);
 export function isGoalPlanV3(plan) {
     return plan?.version === 3;
 }

package/dist/goal-plan.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { LIGHTNING_VIDEO_MODEL } from "./lightning-defaults.js";
 import { GOAL_PROMPT_BUDGET, goalPromptWords } from "./goal-prompt-budget.js";
 import { GOAL_STYLE_IDS, goalStyleFragment, resolveGoalStyleOptions } from "./goal-styles.js";
-export { compileGoalV3Approval, compileGoalV3Steps, goalMediaRefSchema, goalPlanV3Schema, isGoalPlanV3, refreshGoalPlanV3 } from "./goal-plan-v3.js";
+export { compileGoalV3Approval, compileGoalV3Steps, goalMediaRefSchema, goalPlanV3Schema, isGoalPlanV3, refreshGoalPlanV3, savedGoalPlanV3Schema } from "./goal-plan-v3.js";
 export { GOAL_PROMPT_BUDGET, goalPromptWords } from "./goal-prompt-budget.js";
 export const GOAL_VIDEO_TOOL = "generate_video";
 export const GOAL_VIDEO_MODEL = LIGHTNING_VIDEO_MODEL;

package/dist/goal-store.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { firstEmptyNotebookGridSlot, notebookOccupiedSlots } from "videobook-engine/notebook-grid";
-import { goalMediaRefSchema, goalPlanSchema, goalPlanV3Schema, goalStyleSchema, legacyGoalPlanSchema } from "./goal-plan.js";
+import { goalMediaRefSchema, goalPlanSchema, goalStyleSchema, legacyGoalPlanSchema, savedGoalPlanV3Schema } from "./goal-plan.js";
 import { mutateNotebook } from "./notebook-mutations.js";
 import { arrangeGoalNotebook } from "./notebook-goal-layout.js";
 const KEY = "application.goals.v2";
@@ -68,7 +68,7 @@ function mediaFrom(value) {
 }
 export function goalContent(cell) {
     const inputs = cell.inputs ?? {};
-    const plan = z.union([goalPlanV3Schema, goalPlanSchema, legacyGoalPlanSchema]).safeParse(inputs.plan);
+    const plan = z.union([savedGoalPlanV3Schema, goalPlanSchema, legacyGoalPlanSchema]).safeParse(inputs.plan);
     const requestedStyle = goalStyleSchema.safeParse(inputs.requestedStyle);
     const media = mediaFrom(inputs.media);
     return {

package/dist/har-capture.js

@@ -0,0 +1,175 @@
+import { createHash } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHarCapture } from "@apicity/har";
+import { currentBookContext } from "./book-context.js";
+import { harDirectory, readHarSettings } from "./har-settings.js";
+import { logger } from "./logger.js";
+const localFailures = new AsyncLocalStorage();
+const pending = new Set();
+let maintenance = Promise.resolve();
+export async function maintainHarCaptures(operation) {
+    if (pending.size)
+        return false;
+    const next = maintenance.then(operation);
+    maintenance = next.catch(() => undefined);
+    await next;
+    return true;
+}
+export async function flushHarCaptures() {
+    while (pending.size)
+        await Promise.all([...pending]);
+}
+function captureInput(value, seen = new WeakSet()) {
+    if (value instanceof Blob)
+        return { _file: { size: value.size, contentType: value.type } };
+    if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        return { _apicity_placeholder: { bytes: bytes.byteLength, sha256: createHash("sha256").update(bytes).digest("hex") } };
+    }
+    if (!value || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        return "[circular]";
+    seen.add(value);
+    if (value instanceof FormData)
+        return Object.fromEntries(Array.from(value.entries(), ([key, entry]) => [key, captureInput(entry, seen)]));
+    if (Array.isArray(value))
+        return value.map((entry) => captureInput(entry, seen));
+    if (Object.getPrototypeOf(value) !== Object.prototype)
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, key === "otp" ? "***" : captureInput(entry, seen)]));
+}
+export async function withHarCapture(meta, operation, base = globalThis.fetch, context = {}) {
+    for (;;) {
+        const barrier = maintenance;
+        await barrier;
+        if (barrier === maintenance)
+            break;
+    }
+    let finish;
+    const finished = new Promise((resolve) => { finish = resolve; });
+    pending.add(finished);
+    try {
+        return await runCapture(meta, operation, base, context);
+    }
+    catch (error) {
+        localFailures.getStore()?.add(error);
+        throw error;
+    }
+    finally {
+        finish();
+        pending.delete(finished);
+    }
+}
+export async function withHarLocalFailure(meta, operation) {
+    const failures = localFailures.getStore() ?? new Set();
+    return localFailures.run(failures, async () => {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const seen = new Set();
+            let cause = error;
+            while (!seen.has(cause)) {
+                if (failures.has(cause))
+                    throw error;
+                seen.add(cause);
+                if (!(cause instanceof Error) || cause.cause === undefined)
+                    break;
+                cause = cause.cause;
+            }
+            return withHarCapture(meta, () => { throw error; });
+        }
+    });
+}
+async function runCapture(meta, operation, base, context) {
+    const settings = await readHarSettings();
+    if (settings.mode === "off")
+        return operation(base);
+    let input;
+    try {
+        input = captureInput(meta.input);
+    }
+    catch (error) {
+        logger.warn("har-capture-failed", { error });
+        return operation(base);
+    }
+    const book = currentBookContext();
+    const capture = createHarCapture({
+        dir: harDirectory(),
+        mode: settings.mode,
+        context: {
+            bookId: book?.bookId,
+            operation: book?.operation,
+            artifactId: book?.artifactId,
+            attemptId: book?.attemptId ?? book?.artifactId,
+            providerTaskId: book?.providerTaskId,
+            runId: book?.runId,
+            model: book?.model,
+            ...context,
+        },
+        onError: (error) => logger.warn("har-capture-failed", { error }),
+    });
+    const host = { fetch: base };
+    capture.install(host);
+    let finish;
+    const finished = new Promise((resolve) => { finish = resolve; });
+    const done = finished.then(() => capture.close());
+    pending.add(done);
+    void done.finally(() => pending.delete(done));
+    try {
+        return await capture.call({ ...meta, input }, () => operation(host.fetch));
+    }
+    finally {
+        finish();
+    }
+}
+const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
+const SDK_ONLY_NAMESPACES = new Map([["kie", new Set(["veo", "suno"])]]);
+function endpointDotPath(provider, path) {
+    const [head = "", next = ""] = path;
+    if (path.length > 1 && HTTP_METHODS.has(head))
+        return path.slice(1).join(".");
+    if (path.length < 3 || !HTTP_METHODS.has(next))
+        return path.join(".");
+    const rest = path.slice(2);
+    return (SDK_ONLY_NAMESPACES.get(provider)?.has(head) ? rest : [head, ...rest]).join(".");
+}
+const providerCalls = new WeakMap();
+export function withProviderCall(provider, meta, operation) {
+    const state = providerCalls.get(provider);
+    if (!state)
+        return operation(provider);
+    return withHarCapture(meta, (fetch) => state.transports.run(fetch, () => operation(state.original)), state.base);
+}
+export function capturedProvider(provider, factory, base = globalThis.fetch) {
+    const transports = new AsyncLocalStorage();
+    const original = factory((input, init) => {
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+        signal?.throwIfAborted();
+        return (transports.getStore() ?? base)(input, init);
+    });
+    function wrap(target, path) {
+        return new Proxy(target, {
+            apply(fn, receiver, args) {
+                return withHarCapture({ provider, endpoint: endpointDotPath(provider, path), input: args.length === 1 ? args[0] : args }, (fetch) => transports.run(fetch, () => Reflect.apply(fn, receiver, args)), base);
+            },
+            get(object, property, receiver) {
+                const value = Reflect.get(object, property, receiver);
+                if (typeof target === "function" && ["bind", "call", "apply"].includes(String(property)) && typeof value === "function")
+                    return value.bind(receiver);
+                if (typeof property !== "string" || ["presign", "schema", "example", "examples"].includes(property))
+                    return value;
+                const next = [...path, property];
+                if (typeof value === "function")
+                    return wrap(value, next);
+                if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype)
+                    return wrap(value, next);
+                return value;
+            },
+        });
+    }
+    const providerClient = wrap(original, []);
+    providerCalls.set(providerClient, { original, base, transports });
+    return providerClient;
+}

package/dist/har-export.js

@@ -0,0 +1,238 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { mkdir, readdir, readFile, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGzip } from "node:zlib";
+import { scrubHar } from "@apicity/har";
+import { captureFilePath, readCaptureFile, readHarIndex } from "./har-index.js";
+import { installedPackageVersion } from "./package-version.js";
+const BLOCK = 512;
+const OWN_VERSION = createRequire(import.meta.url)("../package.json").version;
+function isHarArchivePath(path) {
+    return /\.(?:tar\.gz|tgz)$/iu.test(path);
+}
+export function selectHarRows(rows, selection) {
+    const seen = new Set();
+    return rows.filter((row) => {
+        if (seen.has(row.file))
+            return false;
+        seen.add(row.file);
+        return (selection.since == null || Date.parse(row.ts) >= selection.since)
+            && (!selection.failures || row.outcome !== "ok")
+            && (!selection.providers?.length || selection.providers.includes(row.provider));
+    });
+}
+function emptyOutcomes() {
+    return { ok: 0, provider_error: 0, local_error: 0, network_error: 0 };
+}
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function verifiedMeta(row, har) {
+    const meta = har.log._apicity;
+    return {
+        ts: meta?.startedAt ?? row.ts,
+        callId: meta?.callId ?? row.callId,
+        provider: meta?.provider ?? row.provider,
+        endpoint: meta?.endpoint ?? row.endpoint,
+        outcome: meta?.outcome ?? row.outcome,
+        status: meta?.status ?? row.status ?? null,
+        context: meta?.context ?? row.context ?? null,
+    };
+}
+function manifestFor(captures, options) {
+    const outcomes = emptyOutcomes();
+    const providers = new Map();
+    const endpoints = new Map();
+    for (const { meta } of captures) {
+        outcomes[meta.outcome] += 1;
+        const provider = providers.get(meta.provider) ?? { provider: meta.provider, calls: 0, outcomes: emptyOutcomes() };
+        provider.calls += 1;
+        provider.outcomes[meta.outcome] += 1;
+        providers.set(meta.provider, provider);
+        const key = JSON.stringify([meta.provider, meta.endpoint]);
+        const endpoint = endpoints.get(key) ?? { provider: meta.provider, endpoint: meta.endpoint, calls: 0, outcomes: emptyOutcomes() };
+        endpoint.calls += 1;
+        endpoint.outcomes[meta.outcome] += 1;
+        endpoints.set(key, endpoint);
+    }
+    const times = captures.map(({ meta }) => meta.ts).sort();
+    return {
+        format: "videobook-har-export",
+        version: 1,
+        createdAt: (options.now ?? new Date()).toISOString(),
+        videobook: OWN_VERSION,
+        apicity: {
+            har: installedPackageVersion("@apicity/har"),
+            captured: [...new Set(captures.map((capture) => capture.apicityVersion))].sort(),
+        },
+        filters: {
+            since: options.since == null ? null : new Date(options.since).toISOString(),
+            failures: Boolean(options.failures),
+            providers: options.providers?.length ? [...options.providers] : null,
+        },
+        files: captures.length,
+        dateRange: { first: times[0] ?? null, last: times.at(-1) ?? null },
+        outcomes,
+        providers: [...providers.values()].sort((a, b) => a.provider.localeCompare(b.provider)),
+        endpoints: [...endpoints.values()].sort((a, b) => a.provider.localeCompare(b.provider) || a.endpoint.localeCompare(b.endpoint)),
+    };
+}
+function indexLines(captures) {
+    return captures.map(({ file, meta }) => `${JSON.stringify({
+        ts: meta.ts,
+        callId: meta.callId,
+        provider: meta.provider,
+        endpoint: meta.endpoint,
+        outcome: meta.outcome,
+        ...(meta.status === null ? {} : { status: meta.status }),
+        file,
+        ...(meta.context ? { context: meta.context } : {}),
+    })}\n`).join("");
+}
+async function* exportEntries(captures, manifest) {
+    yield { path: "manifest.json", bytes: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`) };
+    yield { path: "index.jsonl", bytes: Buffer.from(indexLines(captures)) };
+    for (const capture of captures) {
+        const bytes = await readFile(capture.path);
+        if (sha256(bytes) !== capture.sha256)
+            throw new Error(`${capture.path} changed during the export; run it again`);
+        yield { path: capture.file, bytes };
+    }
+}
+function octal(value, width) {
+    return `${value.toString(8).padStart(width - 1, "0")}\0`;
+}
+function tarHeader(name, size, type, mtime) {
+    const header = Buffer.alloc(BLOCK);
+    header.write(name, 0, 100, "utf8");
+    header.write(octal(0o600, 8), 100, "ascii");
+    header.write(octal(0, 8), 108, "ascii");
+    header.write(octal(0, 8), 116, "ascii");
+    header.write(octal(size, 12), 124, "ascii");
+    header.write(octal(Math.floor(mtime / 1000), 12), 136, "ascii");
+    header.write(" ".repeat(8), 148, "ascii");
+    header.write(type, 156, "ascii");
+    header.write("ustar\0", 257, "ascii");
+    header.write("00", 263, "ascii");
+    const checksum = header.reduce((sum, byte) => sum + byte, 0);
+    header.write(`${checksum.toString(8).padStart(6, "0")}\0 `, 148, "ascii");
+    return header;
+}
+function paxPath(path) {
+    const body = ` path=${path}\n`;
+    const bytes = Buffer.byteLength(body);
+    let length = bytes + String(bytes).length;
+    while (length !== bytes + String(length).length)
+        length = bytes + String(length).length;
+    return Buffer.from(`${length}${body}`);
+}
+function padding(size) {
+    return Buffer.alloc((BLOCK - (size % BLOCK)) % BLOCK);
+}
+async function* tarBlocks(entries, root, mtime) {
+    for await (const entry of entries) {
+        const name = `${root}/${entry.path}`;
+        if (Buffer.byteLength(name) > 100) {
+            const pax = paxPath(name);
+            yield tarHeader("PaxHeader", pax.length, "x", mtime);
+            yield pax;
+            yield padding(pax.length);
+        }
+        yield tarHeader(name, entry.bytes.length, "0", mtime);
+        yield entry.bytes;
+        yield padding(entry.bytes.length);
+    }
+    yield Buffer.alloc(BLOCK * 2);
+}
+async function writeArchive(out, entries, mtime) {
+    const root = basename(out).replace(/\.(?:tar\.gz|tgz)$/iu, "") || "videobook-har";
+    const partial = join(dirname(out), `.${basename(out)}.${randomUUID()}.partial`);
+    try {
+        await pipeline(Readable.from(tarBlocks(entries, root, mtime)), createGzip(), createWriteStream(partial, { flags: "wx", mode: 0o600 }));
+        await rename(partial, out);
+    }
+    catch (error) {
+        await rm(partial, { force: true });
+        throw error;
+    }
+}
+async function writeDirectory(out, entries) {
+    const partial = join(dirname(out), `.${basename(out)}.${randomUUID()}.partial`);
+    try {
+        await mkdir(partial, { mode: 0o700 });
+        for await (const entry of entries) {
+            const target = join(partial, ...entry.path.split("/"));
+            await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+            await writeFile(target, entry.bytes, { flag: "wx", mode: 0o600 });
+        }
+        await rmdir(out).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
+        await rename(partial, out);
+    }
+    catch (error) {
+        await rm(partial, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function outputTaken(out, archive) {
+    try {
+        const info = await stat(out);
+        return archive || !info.isDirectory() || (await readdir(out)).length > 0;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+function inside(parent, child) {
+    const location = relative(resolve(parent), resolve(child));
+    return location === "" || (location !== ".." && !location.startsWith(`..${sep}`) && !isAbsolute(location));
+}
+export async function exportHarCaptures(options) {
+    const archive = isHarArchivePath(options.out);
+    if (inside(options.dir, options.out))
+        return { status: "out-inside-captures", out: options.out };
+    if (await outputTaken(options.out, archive))
+        return { status: "out-exists", out: options.out };
+    const verified = [];
+    const skipped = [];
+    const needsScrub = [];
+    for (const row of selectHarRows(await readHarIndex(options.dir), options)) {
+        const capture = await readCaptureFile(options.dir, row.file);
+        if (!capture) {
+            skipped.push(captureFilePath(options.dir, row.file) ?? row.file);
+            continue;
+        }
+        const before = JSON.stringify(capture.har);
+        if (JSON.stringify(scrubHar(structuredClone(capture.har))) !== before) {
+            needsScrub.push(capture.path);
+            continue;
+        }
+        verified.push({
+            path: capture.path,
+            file: row.file.split(/[\\/]/u).join("/"),
+            sha256: sha256(capture.bytes),
+            meta: verifiedMeta(row, capture.har),
+            apicityVersion: capture.har.log.creator?.version ?? "unknown",
+        });
+    }
+    if (needsScrub.length > 0)
+        return { status: "needs-scrub", files: needsScrub };
+    if (verified.length === 0)
+        return { status: "empty", skipped };
+    const manifest = manifestFor(verified, options);
+    const entries = exportEntries(verified, manifest);
+    await mkdir(dirname(options.out), { recursive: true });
+    if (archive)
+        await writeArchive(options.out, entries, (options.now ?? new Date()).getTime());
+    else
+        await writeDirectory(options.out, entries);
+    return { status: "exported", out: options.out, archive, manifest, skipped };
+}