videobook 0.0.0-stage → 0.2.0

package/dist/posts/dropbox-upload.js

@@ -0,0 +1,132 @@
+import { createHash } from "node:crypto";
+import { extname } from "node:path";
+import { DropboxError } from "@apicity/dropbox";
+import { dropboxClient } from "./dropbox-auth.js";
+import { freezePostOutbound, getPost, patchPostRuntime, readPostRuntime, updatePost } from "./post-store.js";
+const CHUNK = 8 * 1024 * 1024;
+export function dropboxContentHash(bytes) {
+    const hashes = [];
+    for (let offset = 0; offset < bytes.length; offset += 4 * 1024 * 1024)
+        hashes.push(createHash("sha256").update(bytes.subarray(offset, offset + 4 * 1024 * 1024)).digest());
+    return createHash("sha256").update(Buffer.concat(hashes)).digest("hex");
+}
+function correctOffset(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const object = value;
+    if (typeof object.correct_offset === "number")
+        return object.correct_offset;
+    for (const child of Object.values(object)) {
+        const result = correctOffset(child);
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+async function uploadFile(client, bytes, initial, persist, signal) {
+    let state = { ...initial };
+    const save = (patch) => { state = { ...state, ...patch }; persist(state); };
+    try {
+        const metadata = await client.files.getMetadata({ path: state.path }, signal);
+        if (metadata[".tag"] === "file" && metadata.content_hash === state.hash) {
+            save({ id: String(metadata.id), rev: String(metadata.rev), offset: bytes.length });
+            return;
+        }
+        throw new Error("The Dropbox destination already contains different content. Choose a new destination folder.");
+    }
+    catch (error) {
+        if (!(error instanceof DropboxError) || !error.error_summary?.startsWith("path/not_found"))
+            throw error;
+    }
+    if (state.rev)
+        throw new Error("A previously uploaded Dropbox file was removed. Choose a new destination folder.");
+    for (let recovery = 0; recovery < 4; recovery += 1) {
+        try {
+            if (!state.sessionId) {
+                const session = await client.files.uploadSession.start({ contents: new Uint8Array() }, signal);
+                save({ sessionId: session.session_id, offset: 0 });
+            }
+            while (state.offset < bytes.length) {
+                const end = Math.min(state.offset + CHUNK, bytes.length);
+                await client.files.uploadSession.appendV2({ contents: new Uint8Array(bytes.subarray(state.offset, end)), cursor: { session_id: state.sessionId, offset: state.offset } }, signal);
+                save({ offset: end });
+            }
+            const finished = await client.files.uploadSession.finish({ contents: new Uint8Array(), cursor: { session_id: state.sessionId, offset: state.offset }, commit: { path: state.path, mode: "add", autorename: false, mute: true, strict_conflict: true } }, signal);
+            if (finished.content_hash && finished.content_hash !== state.hash)
+                throw new Error("Dropbox returned different file content. Choose a new destination folder.");
+            save({ id: finished.id, rev: finished.rev, offset: bytes.length });
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof DropboxError))
+                throw error;
+            const offset = correctOffset(error.error);
+            if (offset !== null && offset >= 0 && offset <= bytes.length) {
+                save({ offset });
+                continue;
+            }
+            if (error.error_summary?.includes("not_found") || error.error_summary?.includes("closed") || error.error_summary?.includes("conflict")) {
+                try {
+                    const metadata = await client.files.getMetadata({ path: state.path }, signal);
+                    if (metadata[".tag"] === "file" && metadata.content_hash === state.hash) {
+                        save({ id: String(metadata.id), rev: String(metadata.rev), offset: bytes.length });
+                        return;
+                    }
+                    throw new Error("Dropbox destination content changed");
+                }
+                catch (lookup) {
+                    if (!(lookup instanceof DropboxError) || !lookup.error_summary?.startsWith("path/not_found"))
+                        throw lookup;
+                }
+                save({ sessionId: undefined, offset: 0 });
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error("Dropbox upload could not reconcile its saved position. Retry the upload.");
+}
+async function applyCaption(engine, id, caption) {
+    const post = getPost(engine, id);
+    if (caption === undefined || caption === post.definition.caption)
+        return post;
+    if (post.runtime.outbound)
+        throw new Error("This Post's caption was frozen at its first delivery. Create a new Post to deliver a different caption.");
+    return updatePost(engine, id, { caption });
+}
+export async function uploadPostToDropbox(engine, id, options = {}) {
+    if (["posting", "needs_reconciliation", "scheduled"].includes(getPost(engine, id).runtime.status))
+        throw new Error("Resolve or cancel the current publication before uploading");
+    const post = await applyCaption(engine, id, options.caption);
+    const outbound = await freezePostOutbound(engine, id);
+    const folder = options.folder?.replace(/\/+$/, "") ?? post.runtime.dropbox?.folder ?? `/Videobook/${engine.book.get().name}/${id}`;
+    if (!folder.startsWith("/") || folder.includes("..") || [...folder].some(character => character.charCodeAt(0) < 32))
+        throw new Error("Use an absolute Dropbox folder without .. segments");
+    const media = await engine.files.readAtRevision(outbound.artifactId, outbound.filename, outbound.revision);
+    if (!media.ok)
+        throw new Error(media.error.message);
+    const caption = Buffer.from(outbound.caption);
+    const existing = post.runtime.dropbox?.folder === folder ? post.runtime.dropbox : undefined;
+    patchPostRuntime(engine, id, { status: "uploading", error: null, dropbox: existing ?? {
+            folder,
+            video: { path: `${folder}/clip${extname(outbound.filename)}`, hash: dropboxContentHash(media.value), offset: 0 },
+            caption: { path: `${folder}/caption.txt`, hash: dropboxContentHash(caption), offset: 0 },
+        } });
+    try {
+        const client = options.client ?? await dropboxClient();
+        for (const [name, bytes] of [["video", media.value], ["caption", caption]]) {
+            const state = readPostRuntime(engine, id).dropbox;
+            await uploadFile(client, bytes, state[name], (file) => {
+                const current = readPostRuntime(engine, id).dropbox;
+                patchPostRuntime(engine, id, { dropbox: { ...current, [name]: file } });
+            }, options.signal);
+        }
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "ready", error: null, dropbox: { ...readPostRuntime(engine, id).dropbox, completedAt: new Date().toISOString() } });
+        return getPost(engine, id);
+    }
+    catch (error) {
+        const message = error instanceof DropboxError ? `Dropbox upload failed (${error.status}). ${error.status === 401 ? "Reconnect Dropbox and retry." : "Retry to resume the saved upload."}` : error instanceof Error ? error.message : "Dropbox upload failed";
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "failed", error: message });
+        throw new Error(message);
+    }
+}

package/dist/posts/icloud-drive.js

@@ -0,0 +1,134 @@
+import { createHash, randomUUID } from "node:crypto";
+import { copyFile, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, extname, join, resolve, sep } from "node:path";
+import { freezePostOutbound, getPost, patchPostRuntime, readPostRuntime, updatePost } from "./post-store.js";
+import { defaultPostFolderName, icloudFolderError } from "./post-folder.js";
+import { readUbiquitousStates, summarizeUbiquitousSync } from "./icloud-status.js";
+function icloudRoot() {
+    return process.env.VIDEOBOOK_ICLOUD_DIR || join(homedir(), "Library/Mobile Documents/com~apple~CloudDocs/Videobook");
+}
+async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileSize(path) {
+    try {
+        const info = await stat(path);
+        return info.isFile() ? info.size : -1;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function icloudUnavailableReason(root = icloudRoot()) {
+    if (process.platform !== "darwin" && !process.env.VIDEOBOOK_ICLOUD_DIR)
+        return "Saving to iCloud needs the Videobook server running on a Mac.";
+    if (!await isDirectory(dirname(root)))
+        return "iCloud Drive is not set up on this Mac. Turn on iCloud Drive in System Settings.";
+    return null;
+}
+function insideIcloudRoot(root, relativePath) {
+    const rootResolved = resolve(root);
+    const target = resolve(rootResolved, relativePath);
+    if (target !== rootResolved && !target.startsWith(`${rootResolved}${sep}`))
+        throw new Error("iCloud path is outside the Videobook folder.");
+    return target;
+}
+export async function postIcloudSyncStatus(engine, id) {
+    const recorded = getPost(engine, id).runtime.icloud;
+    const relative = [recorded?.video?.path, recorded?.caption?.path].filter((path) => Boolean(path));
+    if (relative.length === 0)
+        return { phase: "not-icloud", error: null };
+    const root = icloudRoot();
+    return summarizeUbiquitousSync(await readUbiquitousStates(relative.map((path) => insideIcloudRoot(root, path))));
+}
+export async function icloudStatus() {
+    const root = icloudRoot();
+    const reason = await icloudUnavailableReason(root);
+    const state = reason ? null : (await readUbiquitousStates([root]))?.[0] ?? null;
+    return { available: !reason, root, shared: state?.ubiquitous ? state.shared : null, role: state?.ubiquitous ? state.role : null, reason };
+}
+async function applyCaption(engine, id, caption) {
+    const post = getPost(engine, id);
+    if (caption === undefined || caption === post.definition.caption)
+        return post;
+    if (post.runtime.outbound)
+        throw new Error("This Post's caption was frozen at its first delivery. Create a new Post to deliver a different caption.");
+    return updatePost(engine, id, { caption });
+}
+async function placeFile(target, bytes) {
+    const stagingDir = join(homedir(), "Library/Caches/videobook/icloud-staging");
+    await mkdir(stagingDir, { recursive: true });
+    const staging = join(stagingDir, randomUUID());
+    await writeFile(staging, bytes);
+    try {
+        await rename(staging, target);
+    }
+    catch (error) {
+        if (!(typeof error === "object" && error !== null && "code" in error && error.code === "EXDEV"))
+            throw error;
+        const partial = join(dirname(target), `.${target.split("/").at(-1)}.videobook-partial`);
+        await copyFile(staging, partial);
+        await rename(partial, target);
+    }
+    finally {
+        await rm(staging, { force: true });
+    }
+}
+async function deliverFile(root, path, bytes, recorded) {
+    const file = { path, sha256: createHash("sha256").update(bytes).digest("hex"), size: bytes.length };
+    const target = join(root, path);
+    const existing = await fileSize(target);
+    if (existing !== null) {
+        if (recorded && recorded.path === file.path && recorded.sha256 === file.sha256 && recorded.size === file.size && existing === file.size)
+            return recorded;
+        throw new Error(`iCloud folder already has a different ${path.split("/").at(-1)}. Choose another folder.`);
+    }
+    await placeFile(target, bytes);
+    return file;
+}
+export async function savePostToICloud(engine, id, options = {}) {
+    if (["posting", "needs_reconciliation", "scheduled"].includes(getPost(engine, id).runtime.status))
+        throw new Error("Resolve or cancel the current publication before saving to iCloud");
+    const root = icloudRoot();
+    const unavailable = await icloudUnavailableReason(root);
+    if (unavailable)
+        throw new Error(unavailable);
+    const current = getPost(engine, id);
+    const folder = (options.folder ?? current.runtime.icloud?.folder ?? defaultPostFolderName(engine.book.get().name, current.address, id)).trim().replace(/\/+$/u, "");
+    const folderError = icloudFolderError(folder);
+    if (folderError)
+        throw new Error(folderError);
+    const post = await applyCaption(engine, id, options.caption);
+    const outbound = await freezePostOutbound(engine, id);
+    const media = await engine.files.readAtRevision(outbound.artifactId, outbound.filename, outbound.revision);
+    if (!media.ok)
+        throw new Error(media.error.message);
+    const existing = post.runtime.icloud?.folder === folder ? post.runtime.icloud : undefined;
+    const state = existing ? { ...existing } : { folder };
+    delete state.completedAt;
+    patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "uploading", error: null, icloud: state });
+    try {
+        await mkdir(join(root, folder), { recursive: true });
+        const files = [["video", `${folder}/clip${extname(outbound.filename)}`, media.value], ["caption", `${folder}/caption.txt`, Buffer.from(outbound.caption)]];
+        for (const [name, path, bytes] of files) {
+            const delivered = await deliverFile(root, path, bytes, state[name]);
+            state[name] = delivered;
+            patchPostRuntime(engine, id, { icloud: { ...readPostRuntime(engine, id).icloud, [name]: delivered } });
+        }
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "ready", error: null, icloud: { ...readPostRuntime(engine, id).icloud, completedAt: new Date().toISOString() } });
+        return getPost(engine, id);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Saving to iCloud failed";
+        patchPostRuntime(engine, id, { status: post.runtime.url ? post.runtime.status : "failed", error: message });
+        throw new Error(message);
+    }
+}

package/dist/posts/icloud-status.js

@@ -0,0 +1,64 @@
+import { execFile } from "node:child_process";
+const SCRIPT = `ObjC.import("Foundation");
+function run(argv) {
+  return JSON.stringify(argv.map(function (path) {
+    var url = $.NSURL.fileURLWithPath(path);
+    function get(key) { var out = Ref(); if (!url.getResourceValueForKeyError(out, key, null)) return null; var v = out[0]; return v === undefined || v === null || (v.isNil && v.isNil()) ? null : ObjC.unwrap(v); }
+    var err = get($.NSURLUbiquitousItemUploadingErrorKey);
+    return { path: path, exists: $.NSFileManager.defaultManager.fileExistsAtPath(path), ubiquitous: get($.NSURLIsUbiquitousItemKey), shared: get($.NSURLUbiquitousItemIsSharedKey), role: get($.NSURLUbiquitousSharedItemCurrentUserRoleKey), uploaded: get($.NSURLUbiquitousItemIsUploadedKey), uploading: get($.NSURLUbiquitousItemIsUploadingKey), error: err ? ObjC.unwrap(err.localizedDescription) : null };
+  }));
+}`;
+function flag(value) {
+    return typeof value === "boolean" ? value : typeof value === "number" ? value !== 0 : null;
+}
+function role(value) {
+    if (typeof value !== "string")
+        return null;
+    if (value.endsWith("Owner"))
+        return "owner";
+    if (value.endsWith("Participant"))
+        return "participant";
+    return null;
+}
+export function parseUbiquitousStates(output) {
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed))
+        throw new Error("Unexpected iCloud status output");
+    return parsed.map((item) => {
+        const record = item && typeof item === "object" ? item : {};
+        const ubiquitous = flag(record.ubiquitous) === true;
+        return {
+            path: typeof record.path === "string" ? record.path : "",
+            exists: record.exists === true,
+            ubiquitous: flag(record.ubiquitous),
+            shared: ubiquitous ? flag(record.shared) ?? false : null,
+            role: ubiquitous ? role(record.role) : null,
+            uploaded: ubiquitous ? flag(record.uploaded) : null,
+            uploading: ubiquitous ? flag(record.uploading) : null,
+            error: typeof record.error === "string" && record.error ? record.error : null,
+        };
+    });
+}
+export function summarizeUbiquitousSync(states) {
+    if (!states || states.length === 0 || states.some((state) => state.ubiquitous !== true))
+        return { phase: "not-icloud", error: null };
+    const error = states.find((state) => state.error)?.error ?? null;
+    if (error)
+        return { phase: "error", error };
+    return states.every((state) => state.uploaded === true && state.uploading !== true)
+        ? { phase: "uploaded", error: null }
+        : { phase: "uploading", error: null };
+}
+export async function readUbiquitousStates(paths) {
+    if (process.platform !== "darwin" || paths.length === 0)
+        return null;
+    try {
+        const output = await new Promise((resolve, reject) => {
+            execFile("osascript", ["-l", "JavaScript", "-e", SCRIPT, ...paths], { timeout: 10_000 }, (error, stdout) => error ? reject(error) : resolve(stdout));
+        });
+        return parseUbiquitousStates(output);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/posts/post-contract.js

@@ -0,0 +1,2 @@
+export const POST_PLATFORMS = ["x", "instagram", "tiktok", "youtube", "other"];
+export const POST_METRIC_NAMES = ["views", "impressions", "likes", "replies", "reposts", "quotes", "bookmarks", "shares", "clicks"];

package/dist/posts/post-copy-format.js

@@ -0,0 +1,43 @@
+export const POST_COPY_LANGUAGES = ["en", "th"];
+export const POST_COPY_LANGUAGE_NAMES = { en: "English", th: "Thai" };
+export const PLATFORM_CAPTION_LIMITS = { x: 280, instagram: 2200, tiktok: 2200, youtube: 5000, other: 2200 };
+export const PLATFORM_TAG_LIMITS = { x: 2, instagram: 10, tiktok: 5, youtube: 15, other: 8 };
+export const PLATFORM_NAMES = { x: "X", instagram: "Instagram", tiktok: "TikTok", youtube: "YouTube Shorts", other: "Other" };
+const TAG_TOKEN = /^#[\p{L}\p{M}\p{N}_]+$/u;
+function normalizePostTag(value) {
+    return value.trim().replace(/^#+/u, "").replace(/[^\p{L}\p{M}\p{N}_]/gu, "");
+}
+export function normalizePostTags(values, limit = Number.POSITIVE_INFINITY) {
+    const seen = new Set();
+    const tags = [];
+    for (const value of values) {
+        const tag = normalizePostTag(value);
+        const key = tag.toLocaleLowerCase();
+        if (!tag || seen.has(key))
+            continue;
+        seen.add(key);
+        tags.push(tag);
+        if (tags.length >= limit)
+            break;
+    }
+    return tags;
+}
+function isTagLine(line) {
+    const tokens = line.trim().split(/\s+/u);
+    return tokens.length > 0 && tokens.every((token) => TAG_TOKEN.test(token));
+}
+export function splitCaptionTags(caption) {
+    const trimmed = caption.trimEnd();
+    const lines = trimmed.split("\n");
+    const last = lines[lines.length - 1] ?? "";
+    if (!last.trim() || !isTagLine(last))
+        return { body: caption, tags: [] };
+    return { body: lines.slice(0, -1).join("\n").trimEnd(), tags: normalizePostTags(last.trim().split(/\s+/u)) };
+}
+export function joinCaptionTags(body, tags) {
+    const line = normalizePostTags(tags).map((tag) => `#${tag}`).join(" ");
+    const text = body.trimEnd();
+    if (!line)
+        return text;
+    return text ? `${text}\n\n${line}` : line;
+}

package/dist/posts/post-copy.js

@@ -0,0 +1,193 @@
+import { chatIntelligenceRequestOptions } from "../chat-models.js";
+import { LIGHTNING_POST_TAGS } from "../lightning-defaults.js";
+import { buildIntelligenceResponses, firstResponseText, intelligenceRequest } from "../openai-intelligence.js";
+import { readAssetTranscript } from "../transcript-projection.js";
+import { isAnalyzableVideo, VIDEO_ANALYSIS_FILE } from "../video-analysis-projection.js";
+import { normalizePostTags, PLATFORM_CAPTION_LIMITS, PLATFORM_NAMES, PLATFORM_TAG_LIMITS, POST_COPY_LANGUAGE_NAMES, } from "./post-copy-format.js";
+const MAX_TRANSCRIPT_CHARS = 4000;
+const MAX_PROMPT_CHARS = 1000;
+const MAX_SCENES = 12;
+const POST_COPY_JSON_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["caption", "tags"],
+    properties: {
+        caption: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+    },
+};
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function texts(value) {
+    return Array.isArray(value) ? value.map(text).filter(Boolean) : [];
+}
+function sceneLines(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(0, MAX_SCENES).map((scene) => {
+        const record = scene && typeof scene === "object" ? scene : {};
+        const at = typeof record.timestamp === "number" ? `${record.timestamp.toFixed(1)}s: ` : "";
+        const description = text(record.description);
+        return description ? `${at}${description}` : "";
+    }).filter(Boolean);
+}
+function postCopyAnalysisFrom(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const record = raw;
+    const analysis = {
+        summary: text(record.summary),
+        mood: text(record.mood),
+        setting: text(record.setting),
+        subjects: texts(record.subjects),
+        actions: texts(record.actions),
+        tags: texts(record.tags),
+        scenes: sceneLines(record.scenes),
+        textOnScreen: texts(record.textOnScreen),
+    };
+    const empty = !analysis.summary && analysis.scenes.length === 0 && analysis.tags.length === 0 && analysis.subjects.length === 0;
+    return empty ? null : analysis;
+}
+async function readAnalysis(engine, assetId) {
+    const read = await engine.files.read(assetId, VIDEO_ANALYSIS_FILE);
+    if (!read.ok)
+        return null;
+    try {
+        return postCopyAnalysisFrom(JSON.parse(read.value.toString()));
+    }
+    catch {
+        return null;
+    }
+}
+function sourceArtifactIds(post) {
+    const source = post.definition.source;
+    if (!source)
+        return [];
+    return [...new Set([source.artifactId, source.snapshotArtifactId].filter((id) => Boolean(id)))];
+}
+export async function postAnalysisTarget(engine, post) {
+    const ids = sourceArtifactIds(post);
+    for (const assetId of ids) {
+        if (await readAnalysis(engine, assetId))
+            return { assetId, analyzable: true, analyzed: true };
+    }
+    const assetId = ids[0];
+    if (!assetId)
+        return null;
+    const artifact = engine.artifacts.get(assetId);
+    return { assetId, analyzable: artifact.ok && isAnalyzableVideo(artifact.value.kind), analyzed: false };
+}
+async function readTranscriptText(engine, assetIds) {
+    for (const assetId of assetIds) {
+        const transcript = await readAssetTranscript(engine, assetId);
+        if (transcript.kind === "timed" || transcript.kind === "plain") {
+            const value = transcript.text.trim();
+            if (value)
+                return value.slice(0, MAX_TRANSCRIPT_CHARS);
+        }
+    }
+    return null;
+}
+export async function readPostCopyContext(engine, post) {
+    const ids = sourceArtifactIds(post);
+    let analysis = null;
+    for (const assetId of ids) {
+        analysis = await readAnalysis(engine, assetId);
+        if (analysis)
+            break;
+    }
+    const prompts = post.definition.lineage
+        .map((step) => text(step.prompt).slice(0, MAX_PROMPT_CHARS))
+        .filter(Boolean)
+        .slice(-2);
+    const label = post.definition.lineage.find((step) => step.cellId === post.definition.source?.cellId)?.label ?? post.label;
+    return { label, analysis, transcript: await readTranscriptText(engine, ids), prompts };
+}
+function listLine(name, values) {
+    return values.length ? `${name}: ${values.join(", ")}` : null;
+}
+function analysisSection(analysis) {
+    if (!analysis)
+        return "VIDEO ANALYSIS: none available. Rely only on the clip label and prompts below.";
+    const lines = [
+        analysis.summary ? `Summary: ${analysis.summary}` : null,
+        analysis.mood ? `Mood: ${analysis.mood}` : null,
+        analysis.setting ? `Setting: ${analysis.setting}` : null,
+        listLine("Subjects", analysis.subjects),
+        listLine("Actions", analysis.actions),
+        listLine("Analysis tags", analysis.tags),
+        listLine("Text on screen", analysis.textOnScreen),
+        analysis.scenes.length ? `Scenes:\n${analysis.scenes.map((scene) => `- ${scene}`).join("\n")}` : null,
+    ].filter((line) => line !== null);
+    return `VIDEO ANALYSIS:\n${lines.join("\n")}`;
+}
+function rewriteSection(request) {
+    const caption = request.caption?.trim();
+    const tags = request.tags?.length ? request.tags.map((tag) => `#${tag}`).join(" ") : "";
+    if (!caption && !tags)
+        return "";
+    return `\nCURRENT DRAFT (rewrite it; keep what already works):\nCaption: ${caption || "(empty)"}\nTags: ${tags || "(none)"}\n`;
+}
+export function buildPostCopyPrompt(context, request) {
+    const platform = PLATFORM_NAMES[request.platform];
+    const language = POST_COPY_LANGUAGE_NAMES[request.language];
+    const limit = PLATFORM_CAPTION_LIMITS[request.platform];
+    const maxTags = PLATFORM_TAG_LIMITS[request.platform];
+    const instruction = request.instruction?.trim();
+    return [
+        `Write the social post copy for one short video clip that will be posted on ${platform}.`,
+        "",
+        "RULES:",
+        `- Write the caption in ${language}${request.language === "th" ? ", natural and conversational, the way a Thai creator writes" : ""}.`,
+        "- Ground every claim in the video analysis, transcript and prompts below. Never invent names, places, events or facts that are not there.",
+        "- By default the caption is a short title of one or two words plus one or two emoji, like \"Golden hour 🌅✨\". Write longer copy only when the instruction asks for it.",
+        "- The title describes this clip. Do not reuse another video's caption.",
+        "- Keep the voice human; no clichés like \"you won't believe\".",
+        "- The caption holds no hashtags. Put hashtags in tags, without the # sign and without spaces.",
+        `- Return at most ${maxTags} tags. Tags may be ${language}${request.language === "en" ? "" : " or English"} words that people on ${platform} search for.`,
+        request.platform === "tiktok" && request.tags === undefined
+            ? "- Include the tags fyp and bkk unless the creator already supplied tags."
+            : "",
+        `- The caption plus its tags must stay under ${limit} characters.`,
+        instruction ? `\nINSTRUCTION FROM THE CREATOR: ${instruction}` : "",
+        rewriteSection(request),
+        `CLIP LABEL: ${context.label}`,
+        analysisSection(context.analysis),
+        context.transcript ? `TRANSCRIPT:\n${context.transcript}` : "TRANSCRIPT: none",
+        context.prompts.length ? `HOW THE CLIP WAS MADE (generation prompts):\n${context.prompts.map((prompt) => `- ${prompt}`).join("\n")}` : "",
+    ].filter((line) => line !== "").join("\n");
+}
+function parsePostCopy(raw, request) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Astra returned post copy that is not JSON.");
+    }
+    const record = parsed && typeof parsed === "object" ? parsed : {};
+    const caption = text(record.caption);
+    if (!caption)
+        throw new Error("Astra returned an empty caption.");
+    const limit = PLATFORM_TAG_LIMITS[request.platform];
+    const parsedTags = normalizePostTags(texts(record.tags), limit);
+    const tags = request.platform === "tiktok" && request.tags === undefined
+        ? normalizePostTags([...LIGHTNING_POST_TAGS, ...parsedTags], limit)
+        : parsedTags;
+    return { caption, tags };
+}
+export function postCopyResponses(apiKey, options = {}) {
+    const astra = chatIntelligenceRequestOptions();
+    return buildIntelligenceResponses(apiKey, { timeout: 120_000, model: astra.model, reasoningEffort: astra.reasoningEffort, ...options });
+}
+export async function draftPostCopy(responses, context, request, signal) {
+    const options = chatIntelligenceRequestOptions();
+    const response = await responses(intelligenceRequest({
+        input: [{ role: "user", content: buildPostCopyPrompt(context, request) }],
+        text: { format: { type: "json_schema", name: "post_copy", schema: POST_COPY_JSON_SCHEMA, strict: true } },
+        max_output_tokens: 4096,
+    }, options), signal);
+    const copy = parsePostCopy(firstResponseText(response), request);
+    return { ...copy, platform: request.platform, language: request.language, model: options.model, analyzed: context.analysis !== null };
+}

package/dist/posts/post-folder.js

@@ -0,0 +1,18 @@
+function folderSegment(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "") || "book";
+}
+export function defaultPostFolderName(bookName, address, postId) {
+    return `${folderSegment(bookName)}/post-${address.replace(/^@/u, "")}-${postId.slice(-6)}`;
+}
+export function icloudFolderError(folder) {
+    const trimmed = folder.trim().replace(/\/+$/u, "");
+    if (!trimmed)
+        return "Choose an iCloud folder.";
+    if (trimmed.startsWith("/") || trimmed.startsWith("~"))
+        return "Use a folder inside iCloud Drive › Videobook, like my-book/post-a1.";
+    if ([...trimmed].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127))
+        return "Use an iCloud folder without control characters.";
+    if (trimmed.split("/").some(segment => segment === ".." || segment === "." || segment === ""))
+        return "Use an iCloud folder without empty, . or .. segments.";
+    return null;
+}