@docyrus/animaguru 0.8.1 → 0.10.0

package/dist/animaguru.js

@@ -542,7 +542,7 @@ var init_dist = __esm({
 // cli/package.json
 var package_default = {
   name: "@docyrus/animaguru",
-  version: "0.8.1",
+  version: "0.10.0",
   description: "Agent-friendly AnimaGuru CLI built with CrustJS",
   type: "module",
   bin: {
@@ -2670,9 +2670,9 @@ var styleMethodCodes = {
 };
 var styleMethodNames = Object.freeze(Object.keys(styleMethodCodes));
 var styleMethodPairs = Object.freeze(Object.fromEntries(styleMethodNames.map((name) => {
-  const [open3, close] = styleMethodCodes[name];
+  const [open6, close] = styleMethodCodes[name];
   return [name, {
-    open: `\x1B[${open3}m`,
+    open: `\x1B[${open6}m`,
     close: `\x1B[${close}m`
   }];
 })));
@@ -3479,9 +3479,9 @@ function applyStyle(text, style2) {
   if (text == null) return "";
   let result = String(text);
   if (result === "") return "";
-  const { open: open3, close } = style2;
-  if (result.includes(close)) result = result.replaceAll(close, close + open3);
-  return open3 + result + close;
+  const { open: open6, close } = style2;
+  if (result.includes(close)) result = result.replaceAll(close, close + open6);
+  return open6 + result + close;
 }
 var FG_CLOSE = "\x1B[39m";
 var BG_CLOSE = "\x1B[49m";
@@ -3684,15 +3684,15 @@ function buildChainableStyleFactory(resolveCapabilities, runtime) {
       value: (input2) => createChainableStyle([...steps, colorStep(kind, input2)]),
       writable: false
     });
-    let open3 = "";
+    let open6 = "";
     let close = "";
     for (const step of steps) {
       const pair = stepPair(step, pairDepth);
-      open3 += pair.open;
+      open6 += pair.open;
       close = pair.close + close;
     }
     Object.defineProperty(styleFn, "open", {
-      value: open3,
+      value: open6,
       writable: false,
       configurable: false,
       enumerable: true
@@ -5076,9 +5076,9 @@ var version = defineExtension(VERSION).factory((extension, value, options = {})
 
 // cli/src/commands.ts
 import { spawn as spawn3 } from "node:child_process";
-import { readFile as readFile8, writeFile as writeFile8 } from "node:fs/promises";
-import { resolve as resolve9 } from "node:path";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { resolve as resolve11 } from "node:path";
+import { setTimeout as delay3 } from "node:timers/promises";
 
 // node_modules/fflate/esm/index.mjs
 import { createRequire } from "module";
@@ -6067,7 +6067,7 @@ function unzipSync(data, opts) {
 }
 
 // shared/auth.ts
-var CLI_CLIENT_ID = "spriteguru-cli";
+var CLI_CLIENT_ID = "animaguru-cli";
 
 // shared/sprites/styles.ts
 var GAME_SPRITE_STYLES = ["hd-cartoon", "pixel", "painted", "vector"];
@@ -11223,7 +11223,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve10) {
+function isRecursive(inst, stack, resolve12) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -11233,7 +11233,7 @@ function isRecursive(inst, stack, resolve10) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve10);
+      const answer = isRecursive(child, stack, resolve12);
       if (answer > result)
         result = answer;
     }
@@ -11244,7 +11244,7 @@ function isRecursive(inst, stack, resolve10) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve10) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve12) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -11308,7 +11308,7 @@ function isRecursive(inst, stack, resolve10) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve10 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve12 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -25993,12 +25993,10 @@ import { fileURLToPath } from "node:url";
 
 // shared/locales/en/animation-styles.json
 var animation_styles_default = {
-  videos: "Videos",
   pageTitle: "Animation styles \xB7 AnimaGuru",
   eyebrow: "THE STYLE GALLERY",
   title: "Find the way\nyour story moves.",
   description: "Explore the visual language of your next animation. Choose a style here, then tell your coding agent which one you like.",
-  openStudio: "Open studio",
   available: "AVAILABLE NOW",
   previewLabel: "{{name}} style preview",
   previewError: "The preview could not load. Try reloading the page.",
@@ -26016,7 +26014,6 @@ var animation_styles_default = {
   firstStep: "Create a project",
   secondStep: "Choose the purpose of your video",
   thirdStep: "Pick a style with your agent",
-  footer: "AnimaGuru \xB7 Imagine. Create. Animate.",
   categories: {
     explainer: {
       name: "Explainer",
@@ -27002,8 +26999,8 @@ async function createWorkspace(options, installer = installDependencies) {
   await rm2(join5(directory, "runtime/main.ts"));
   await rename3(join5(directory, "film.config.json"), join5(directory, "templates/animation/film.config.json"));
   await rename3(join5(directory, "shared/locales/en/film.json"), join5(directory, "templates/animation/shared/locales/en/film.json"));
-  const { createHash: createHash2 } = await import("node:crypto");
-  await writeFile6(join5(directory, "templates/animation/starter-film.sha256"), createHash2("sha256").update(await readFile4(join5(directory, "templates/animation/src/film.ts"))).digest("hex") + "\n");
+  const { createHash: createHash5 } = await import("node:crypto");
+  await writeFile6(join5(directory, "templates/animation/starter-film.sha256"), createHash5("sha256").update(await readFile4(join5(directory, "templates/animation/src/film.ts"))).digest("hex") + "\n");
   await rm2(join5(directory, "animaguru.project.json"));
   await mkdir6(join5(directory, "animations"));
   await mkdir6(join5(directory, "branding"));
@@ -27187,7 +27184,7 @@ function elevenLabsSpeechCostUsd(model, characters, now = Date.now()) {
   const rate = model === "eleven_v4_turbo" ? promotion ? 0.011 : 0.04 : promotion ? 0.022 : 0.08;
   return Math.max(0, characters) * rate / 1e3;
 }
-var elevenLabsSfxCostUsd = (seconds) => Math.max(0, seconds) * 0.12 / 60;
+var elevenLabsSfxCostUsd = (seconds2) => Math.max(0, seconds2) * 0.12 / 60;
 var speechCharacters = (text) => Array.from(text).length;
 function assetEstimate(p) {
   if (p.type === "image") return Math.ceil(130 * spriteImageModel(p.model).relCost);
@@ -27199,16 +27196,21 @@ function assetEstimate(p) {
 }
 
 // cli/src/videos.ts
-import { open as open2, readFile as readFile6, stat } from "node:fs/promises";
-import { basename as basename3, join as join7, resolve as resolve7 } from "node:path";
+import { open as open3, readFile as readFile7, stat as stat2 } from "node:fs/promises";
+import { basename as basename4, join as join7, resolve as resolve8 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { spawn as spawn2 } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 
 // shared/videos.ts
 var VIDEO_PART_BYTES = 8 * 1024 * 1024;
 var VIDEO_MAX_BYTES = { html5: 64 * 1024 * 1024, mp4: 512 * 1024 * 1024 };
 var VIDEO_VISIBILITIES = ["private", "public"];
+var VIDEO_SHARING_AGREEMENT_VERSION = "2026-10-10-draft-1";
+var videoAgreementAcceptance = external_exports.object({
+  version: external_exports.literal(VIDEO_SHARING_AGREEMENT_VERSION),
+  language: external_exports.enum(["en", "tr"])
+}).strict();
 var recipients = external_exports.array(external_exports.email().trim().toLowerCase()).max(20).transform((values) => [...new Set(values)]).default([]);
 var videoMetadataUpdate = external_exports.object({
   title: external_exports.string().trim().min(1).max(120),
@@ -27216,13 +27218,15 @@ var videoMetadataUpdate = external_exports.object({
 }).strict();
 var videoSharingUpdate = external_exports.object({
   visibility: external_exports.enum(VIDEO_VISIBILITIES),
-  recipients
+  recipients,
+  agreement: videoAgreementAcceptance.optional()
 }).strict().refine((value) => value.visibility !== "public" || !value.recipients.length, "Public videos do not use a recipient list.");
 var videoDetails = external_exports.object({
   title: external_exports.string().trim().min(1).max(120),
   description: external_exports.string().trim().max(2e3).default(""),
   visibility: external_exports.enum(VIDEO_VISIBILITIES).default("private"),
-  recipients
+  recipients,
+  agreement: videoAgreementAcceptance.optional()
 }).refine((value) => value.visibility !== "public" || !value.recipients.length, "Public videos do not use a recipient list.");
 var videoSubmission = videoDetails.and(external_exports.object({
   format: external_exports.enum(["html5", "mp4"]),
@@ -27238,11 +27242,158 @@ function videoPosterType(bytes) {
   throw new Error("Use a PNG, JPEG or WebP poster up to 2 MiB.");
 }
 
+// shared/subtitles.ts
+var SUBTITLE_MAX_BYTES = 1024 * 1024;
+var MAX_CUES = 5e3;
+var MAX_CUE_TEXT = 1e3;
+var MAX_SECONDS = 7200;
+var subtitleLanguage = external_exports.string().regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/, "Use a subtitle language code such as en, tr or pt-BR.");
+var TIME = /^(?:(\d{1,3}):)?(\d{1,2}):(\d{2})[.,](\d{3})$/;
+function seconds(value) {
+  const match = TIME.exec(value.trim());
+  if (!match || Number(match[2]) > 59 || Number(match[3]) > 59) return NaN;
+  return Number(match[1] ?? 0) * 3600 + Number(match[2]) * 60 + Number(match[3]) + Number(match[4]) / 1e3;
+}
+var subRipText = (text) => text.replace(/<(?!\/?[ibu]>)[^<>]*>/gi, "").replace(/&(?!(?:[a-z][a-z\d]*|#\d+|#x[\da-f]+);)/gi, "&amp;").replace(/<(?!\/?[ibu]>)/gi, "&lt;");
+function parseSubtitles(input2, duration3) {
+  const text = input2.replace(/^/, "").replace(/\r\n?/g, "\n");
+  if (text.includes("\0") || text.includes("\uFFFD")) throw new Error("Use a UTF-8 text subtitle file.");
+  const vtt = /^WEBVTT(?:[ \t][^\n]*)?(?:\n|$)/.test(text);
+  const cues = [];
+  for (const [index, block] of text.split(/\n[ \t]*\n/).entries()) {
+    const lines = block.split("\n").filter((line) => line.trim());
+    if (!lines.length || vtt && (index === 0 || /^(?:NOTE|STYLE|REGION)(?:[ \t]|$)/.test(lines[0]))) continue;
+    const timing = lines.findIndex((line) => line.includes("-->"));
+    if (timing < 0 || timing > 1) throw new Error(`Subtitle block ${index + 1} has no "start --> end" timing line.`);
+    const [from, rest = ""] = lines[timing].split("-->");
+    const start = seconds(from);
+    let end = seconds(rest.trim().split(/[ \t]+/)[0] ?? "");
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start || end > MAX_SECONDS) throw new Error(`Subtitle block ${index + 1} has an invalid timing: ${lines[timing].trim().slice(0, 60)}`);
+    const body = lines.slice(timing + 1).filter((line) => !line.includes("-->")).map((line) => line.trimEnd()).join("\n").trim();
+    if (!body) continue;
+    const cueText = vtt ? body : subRipText(body);
+    if (cueText.length > MAX_CUE_TEXT) throw new Error(`Subtitle block ${index + 1} is longer than ${MAX_CUE_TEXT} characters.`);
+    if (duration3 != null) {
+      if (start >= duration3) continue;
+      end = Math.min(end, duration3);
+    }
+    cues.push({ start, end, text: cueText });
+    if (cues.length > MAX_CUES) throw new Error(`Subtitle files can have up to ${MAX_CUES} captions.`);
+  }
+  if (!cues.length) throw new Error("The subtitle file has no timed captions.");
+  return cues.sort((a, b) => a.start - b.start || a.end - b.end);
+}
+
+// cli/src/export-files.ts
+import { open as open2, readFile as readFile5, stat } from "node:fs/promises";
+import { basename as basename3, resolve as resolve6 } from "node:path";
+import { createHash } from "node:crypto";
+async function exportReceipt(file2) {
+  try {
+    const receipt = JSON.parse(await readFile5(file2.replace(/\.mp4$/i, ".json"), "utf8"));
+    if (receipt.file !== basename3(file2)) return {};
+    return { title: typeof receipt.title === "string" ? receipt.title : void 0, language: typeof receipt.settings?.language === "string" ? receipt.settings.language : void 0 };
+  } catch {
+    return {};
+  }
+}
+async function readSubtitleFile(file2, maxBytes) {
+  let info;
+  try {
+    info = await stat(file2);
+  } catch {
+    throw new Error(`Cannot read the subtitle file ${file2}.`);
+  }
+  if (!info.isFile() || !/\.(?:srt|vtt)$/i.test(file2) || info.size < 1 || info.size > maxBytes) throw new Error(`Use a .srt or .vtt subtitle file up to ${maxBytes / 1024 / 1024} MiB, such as the one npm run export:mp4 writes beside the MP4.`);
+  const content = await readFile5(file2);
+  const text = content.toString("utf8");
+  if (text.includes("\uFFFD") || !/\d\d:\d\d[,.]\d{3} --> /.test(text)) throw new Error("Use a UTF-8 .srt or .vtt subtitle file with timed captions.");
+  return { content, sha256: createHash("sha256").update(content).digest("hex"), language: /^\uFEFF?WEBVTT[^\n]*\n(?:[^\n]+\n)*?Language:[ \t]*([^\s]+)/.exec(text)?.[1] };
+}
+async function subtitleFile(root, mp4, choice, extensions) {
+  if (choice === "none") return null;
+  if (choice !== "auto") return { file: resolve6(root, choice), explicit: true };
+  for (const extension of extensions) {
+    const file2 = mp4.replace(/\.mp4$/i, extension);
+    if (await stat(file2).then((info) => info.isFile(), () => false)) return { file: file2, explicit: false };
+  }
+  return null;
+}
+function* boxes(data) {
+  for (let offset = 0; offset + 8 <= data.length; ) {
+    let size = data.readUInt32BE(offset);
+    let header = 8;
+    if (size === 1) {
+      size = Number(data.readBigUInt64BE(offset + 8));
+      header = 16;
+    } else if (size === 0) size = data.length - offset;
+    if (size < header || offset + size > data.length) return;
+    yield { type: data.toString("latin1", offset + 4, offset + 8), body: data.subarray(offset + header, offset + size) };
+    offset += size;
+  }
+}
+async function mp4Info(file2) {
+  const handle = await open2(file2, "r");
+  try {
+    const { size } = await handle.stat();
+    const read2 = async (offset, length) => {
+      const buffer = Buffer.alloc(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, offset);
+      return buffer.subarray(0, bytesRead);
+    };
+    let moov = null;
+    for (let offset = 0; offset + 8 <= size; ) {
+      const header = await read2(offset, 16);
+      let length = header.readUInt32BE(0);
+      let headerSize = 8;
+      if (length === 1) {
+        length = Number(header.readBigUInt64BE(8));
+        headerSize = 16;
+      } else if (length === 0) length = size - offset;
+      if (length < headerSize) break;
+      if (header.toString("latin1", 4, 8) === "moov") {
+        if (length <= 64 * 1024 * 1024) moov = await read2(offset + headerSize, length - headerSize);
+        break;
+      }
+      offset += length;
+    }
+    if (!moov) return null;
+    let duration3 = 0;
+    let width = 0;
+    let height = 0;
+    for (const box of boxes(moov)) {
+      if (box.type === "mvhd" && box.body.length >= 32) {
+        const long = box.body[0] === 1;
+        const timescale = box.body.readUInt32BE(long ? 20 : 12);
+        const units = long ? Number(box.body.readBigUInt64BE(24)) : box.body.readUInt32BE(16);
+        if (timescale) duration3 = units / timescale;
+      } else if (box.type === "trak" && !width) {
+        let tkhd;
+        let handler = "";
+        for (const child of boxes(box.body)) {
+          if (child.type === "tkhd") tkhd = child.body;
+          if (child.type === "mdia") {
+            for (const media of boxes(child.body)) if (media.type === "hdlr" && media.body.length >= 12) handler = media.body.toString("latin1", 8, 12);
+          }
+        }
+        const at = tkhd?.[0] === 1 ? 88 : 76;
+        if (handler !== "vide" || !tkhd || tkhd.length < at + 8) continue;
+        width = Math.round(tkhd.readUInt32BE(at) / 65536);
+        height = Math.round(tkhd.readUInt32BE(at + 4) / 65536);
+        if (tkhd.readInt32BE(at - 36) === 0 && tkhd.readInt32BE(at - 20) === 0) [width, height] = [height, width];
+      }
+    }
+    return width && height && duration3 ? { width, height, duration: Math.round(duration3 * 1e3) / 1e3 } : null;
+  } finally {
+    await handle.close();
+  }
+}
+
 // cli/src/local-project.ts
-import { readFile as readFile5, readdir as readdir2 } from "node:fs/promises";
-import { join as join6, relative, resolve as resolve6, sep } from "node:path";
+import { readFile as readFile6, readdir as readdir2 } from "node:fs/promises";
+import { join as join6, relative, resolve as resolve7, sep } from "node:path";
 async function localProject(directory, selected) {
-  const root = resolve6(directory);
+  const root = resolve7(directory);
   let workspace;
   try {
     workspace = await findWorkspace(root);
@@ -27257,7 +27408,7 @@ async function localProject(directory, selected) {
     for (const entry of await readdir2(join6(workspace, "animations"), { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       try {
-        await readFile5(join6(workspace, "animations", entry.name, "animaguru.project.json"));
+        await readFile6(join6(workspace, "animations", entry.name, "animaguru.project.json"));
         names.push(entry.name);
       } catch (error62) {
         if (error62.code !== "ENOENT") throw error62;
@@ -27268,17 +27419,18 @@ async function localProject(directory, selected) {
   }
   if (!/^[a-z0-9][a-z0-9-]{0,79}$/.test(animation)) throw new Error("Use a lowercase, hyphenated animation name.");
   const projectRoot = join6(workspace, "animations", animation);
-  await readFile5(join6(projectRoot, "animaguru.project.json"));
+  await readFile6(join6(projectRoot, "animaguru.project.json"));
   return { toolsRoot: workspace, projectRoot, animation };
 }
 
 // cli/src/videos.ts
+var subtitlesBody = (content) => new Blob([new Uint8Array(content)], { type: "text/plain; charset=utf-8" });
 function sharingEmails(value) {
   return value ? value.split(",").map((email3) => email3.trim()).filter(Boolean) : [];
 }
 async function exportHtml(root, animation, signal, log) {
   const script = join7(root, "scripts/export-html.mjs");
-  await stat(script).catch(() => {
+  await stat2(script).catch(() => {
     throw new Error("Choose an AnimaGuru video project, or pass --file for an exported HTML5 ZIP or MP4.");
   });
   log?.("Building the portable HTML5 animation\u2026");
@@ -27310,25 +27462,26 @@ async function exportHtml(root, animation, signal, log) {
 }
 async function submitVideo(client, options) {
   if (!options.yes && !options["dry-run"]) throw new Error("Pass --yes to authorize uploading and sharing this animation, or --dry-run to inspect the submission.");
-  const root = resolve7(options.directory ?? ".");
+  const root = resolve8(options.directory ?? ".");
   const context = await localProject(root, options.animation);
-  const file2 = options.file ? resolve7(root, options.file) : await exportHtml(context.toolsRoot, context.animation, options.signal, options.log);
-  const info = await stat(file2);
+  const file2 = options.file ? resolve8(root, options.file) : await exportHtml(context.toolsRoot, context.animation, options.signal, options.log);
+  const info = await stat2(file2);
   const format = file2.toLowerCase().endsWith(".zip") ? "html5" : file2.toLowerCase().endsWith(".mp4") ? "mp4" : null;
   if (!info.isFile() || !format) throw new Error("Submit an AnimaGuru HTML5 .zip export or an .mp4 file.");
   videoSubmission.parse({ title: options.title ?? "Video", format, bytes: info.size });
   let metadata = {};
+  let receipt = {};
   if (format === "html5") {
-    const files = unzipSync(new Uint8Array(await readFile6(file2)), { filter: (entry) => entry.name === "manifest.json" && entry.originalSize <= 256 * 1024 });
+    const files = unzipSync(new Uint8Array(await readFile7(file2)), { filter: (entry) => entry.name === "manifest.json" && entry.originalSize <= 256 * 1024 });
     if (!files["manifest.json"]) throw new Error("Use an AnimaGuru HTML5 export with manifest.json.");
     metadata = JSON.parse(strFromU8(files["manifest.json"]));
     if (metadata.format !== "spriteguru-html5" || metadata.version !== 1) throw new Error("Use an AnimaGuru HTML5 export.");
   } else {
     try {
-      metadata = JSON.parse(await readFile6(join7(context.projectRoot, "film.config.json"), "utf8"));
+      metadata = JSON.parse(await readFile7(join7(context.projectRoot, "film.config.json"), "utf8"));
     } catch {
     }
-    const handle2 = await open2(file2, "r");
+    const handle2 = await open3(file2, "r");
     try {
       const header = Buffer.alloc(12);
       await handle2.read(header, 0, 12, 0);
@@ -27336,9 +27489,13 @@ async function submitVideo(client, options) {
     } finally {
       await handle2.close();
     }
+    receipt = await exportReceipt(file2);
+    const probe = await mp4Info(file2).catch(() => null);
+    if (!probe) options.log?.("Could not read the MP4's size and duration; using film.config.json.");
+    metadata = { ...metadata, ...receipt.title ? { title: receipt.title } : {}, ...probe };
   }
   const body = videoSubmission.parse({
-    title: options.title ?? metadata.title ?? basename3(file2).replace(/\.(zip|mp4)$/i, ""),
+    title: options.title ?? metadata.title ?? basename4(file2).replace(/\.(zip|mp4)$/i, ""),
     description: options.description ?? "",
     visibility: options.visibility ?? "private",
     recipients: sharingEmails(options.share),
@@ -27348,19 +27505,30 @@ async function submitVideo(client, options) {
     height: metadata.height,
     duration: metadata.duration
   });
+  let subtitles = null;
+  const choice = options.subtitles ?? "auto";
+  if (format === "html5" && choice !== "auto" && choice !== "none") throw new Error("Subtitle files are for MP4 uploads; HTML5 films show their own captions.");
+  const found = format === "mp4" ? await subtitleFile(root, file2, choice, [".vtt", ".srt"]) : null;
+  if (found) {
+    const { content, language: header } = await readSubtitleFile(found.file, SUBTITLE_MAX_BYTES);
+    const language = subtitleLanguage.safeParse(options["subtitle-language"] ?? header ?? receipt.language ?? metadata.language);
+    if (!language.success) throw new Error("Pass --subtitle-language with the subtitles' language code, such as en or tr.");
+    parseSubtitles(content.toString("utf8"), body.duration);
+    subtitles = { file: found.file, language: language.data, content };
+  }
   let poster;
   if (options.poster) {
-    const path = resolve7(root, options.poster);
-    const info2 = await stat(path);
+    const path = resolve8(root, options.poster);
+    const info2 = await stat2(path);
     if (!info2.isFile() || info2.size > 2 * 1024 * 1024) throw new Error("Poster must be a PNG, JPEG or WebP up to 2 MiB.");
-    poster = await readFile6(path);
+    poster = await readFile7(path);
     videoPosterType(poster);
   }
-  if (options["dry-run"]) return { dryRun: true, file: file2, submission: body, poster: options.poster ?? null };
+  if (options["dry-run"]) return { dryRun: true, file: file2, submission: body, poster: options.poster ?? null, subtitles: subtitles && { file: subtitles.file, language: subtitles.language } };
   const draft = await client.request("/api/v1/videos", { method: "POST", body });
   if (!Number.isInteger(draft.partBytes) || draft.partBytes < 1 || draft.partBytes > 8 * 1024 * 1024 || !/^vid_[a-f0-9]{32}$/.test(draft.id)) throw new Error("The server returned an invalid video upload session.");
-  const handle = await open2(file2, "r");
-  let completed = false;
+  const handle = await open3(file2, "r");
+  let completed2 = false;
   try {
     for (let offset = 0, part = 1; offset < info.size; offset += draft.partBytes, part++) {
       options.signal?.throwIfAborted();
@@ -27368,7 +27536,7 @@ async function submitVideo(client, options) {
       const read2 = await handle.read(bytes, 0, bytes.length, offset);
       if (read2.bytesRead !== bytes.length) throw new Error("The export changed while uploading. Retry with a stable exported file.");
       options.log?.(`Uploading part ${part}/${Math.ceil(info.size / draft.partBytes)}\u2026`);
-      const sha256 = createHash("sha256").update(bytes).digest("hex");
+      const sha256 = createHash2("sha256").update(bytes).digest("hex");
       for (let attempt = 0; ; attempt++) {
         try {
           await client.request(`/api/v1/videos/${draft.id}/parts/${part}`, { method: "PUT", body: new Blob([bytes]), headers: { "X-Content-SHA256": sha256 }, timeout: 18e4 });
@@ -27380,21 +27548,40 @@ async function submitVideo(client, options) {
       }
     }
     if (poster) await client.request(`/api/v1/videos/${draft.id}/poster`, { method: "PUT", body: new Blob([new Uint8Array(poster)]) });
+    if (subtitles) {
+      options.log?.(`Adding ${subtitles.language} subtitles from ${subtitles.file}\u2026`);
+      await client.request(`/api/v1/videos/${draft.id}/subtitles/${subtitles.language}`, { method: "PUT", body: subtitlesBody(subtitles.content) });
+    }
     options.log?.("Preparing your AnimaGuru player\u2026");
     const result = await client.request(`/api/v1/videos/${draft.id}/complete`, { method: "POST", timeout: 3e5 });
-    completed = true;
+    completed2 = true;
     return { ...result, url: new URL(result.url, client.origin).href };
   } catch (error62) {
-    if (!completed) options.log?.(`Submission interrupted. Video ID: ${draft.id}. Inspect it with animaguru videos get ${draft.id}; finish with animaguru videos complete ${draft.id}, or cancel with animaguru videos delete ${draft.id} --yes.`);
+    if (!completed2) options.log?.(`Submission interrupted. Video ID: ${draft.id}. Inspect it with animaguru videos get ${draft.id}; finish with animaguru videos complete ${draft.id}, or cancel with animaguru videos delete ${draft.id} --yes.`);
     throw error62;
   } finally {
     await handle.close();
   }
 }
+async function changeVideoSubtitles(client, id2, options) {
+  if (!options.yes) throw new Error("Pass --yes to change this video's subtitles.");
+  const path = `/api/v1/videos/${encodeURIComponent(id2)}/subtitles/`;
+  if (options.remove) {
+    if (options.file) throw new Error("Pass either --file or --remove.");
+    return client.request(path + encodeURIComponent(options.remove), { method: "DELETE" });
+  }
+  if (!options.file) throw new Error("Pass --file with a .srt or .vtt subtitle file, or --remove LANGUAGE.");
+  const file2 = resolve8(options.file);
+  const { content, language: header } = await readSubtitleFile(file2, SUBTITLE_MAX_BYTES);
+  const language = subtitleLanguage.safeParse(options.language ?? header ?? (await exportReceipt(file2.replace(/\.(?:srt|vtt)$/i, ".mp4"))).language);
+  if (!language.success) throw new Error("Pass --language with the subtitles' language code, such as en or tr.");
+  parseSubtitles(content.toString("utf8"));
+  return client.request(path + language.data, { method: "PUT", body: subtitlesBody(content) });
+}
 
 // cli/src/assets.ts
-import { readFile as readFile7, writeFile as writeFile7 } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
 var extras = { image: ["aspect-ratio", "transparent"], video: ["workflow", "reference", "end-reference", "source", "soundtrack", "audio-references", "seconds", "resolution", "mode", "aspect-ratio", "prompt-expansion", "seed", "extend-output"], music: [], speech: ["voice", "delivery"], sfx: ["seconds", "loop", "prompt-influence"] };
 function parseAsset(input2) {
   const parsed = assetRequest.safeParse(input2);
@@ -27432,7 +27619,7 @@ function assetFromFlags(flags) {
   return parseAsset({ ...base2, ...flags.type === "speech" ? { voice: flags.voice, delivery: flags.delivery } : {} });
 }
 async function assetFromFile(file2, model) {
-  const input2 = JSON.parse(await readFile7(file2, "utf8"));
+  const input2 = JSON.parse(await readFile8(file2, "utf8"));
   if (!input2 || typeof input2 !== "object" || Array.isArray(input2)) throw new Error("The asset file must contain a JSON object.");
   return parseAsset({ ...input2, ...model ? { model } : {} });
 }
@@ -27447,12 +27634,772 @@ async function downloadAsset(client, project, assetId, output2) {
   if (!asset) throw new Error("Asset not found in this project. Run assets list to find its id.");
   if (!library.ownerId || !/^[a-f0-9]{64}$/.test(asset.file)) throw new Error("Invalid asset download metadata.");
   const response = await client.request(`/api/v1/blobs/${encodeURIComponent(library.ownerId)}/${asset.file}`, { raw: true });
-  const path = resolve8(output2);
+  const path = resolve9(output2);
   const bytes = new Uint8Array(await response.arrayBuffer());
   await writeFile7(path, bytes, { flag: "wx" });
   return { path, id: asset.id, type: asset.type, mimeType: asset.mimeType, size: bytes.byteLength };
 }
 
+// cli/src/youtube-auth.ts
+import { createServer } from "node:http";
+import { randomBytes, createHash as createHash3, timingSafeEqual } from "node:crypto";
+import { readFile as readFile10, stat as stat3 } from "node:fs/promises";
+
+// cli/src/youtube-store.ts
+import { chmod as chmod3, lstat, mkdir as mkdir7, open as open4, readFile as readFile9, readdir as readdir3, rename as rename4, unlink, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname6, join as join8 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var youtubeMetadata = external_exports.object({
+  title: external_exports.string().trim().min(1).max(100).refine((value) => !/[<>]/.test(value)),
+  description: external_exports.string().max(5e3).refine((value) => Buffer.byteLength(value, "utf8") <= 5e3 && !/[<>]/.test(value)),
+  privacy: external_exports.enum(["private", "unlisted", "public"]),
+  madeForKids: external_exports.boolean(),
+  syntheticMedia: external_exports.boolean()
+}).strict();
+var youtubeCredentials = external_exports.object({
+  clientId: external_exports.string().min(1),
+  clientSecret: external_exports.string().optional(),
+  accessToken: external_exports.string().min(1),
+  refreshToken: external_exports.string().min(1),
+  expiresAt: external_exports.number().finite(),
+  channelId: external_exports.string().min(1),
+  channelTitle: external_exports.string().min(1),
+  connectedAt: external_exports.number(),
+  checkedAt: external_exports.number(),
+  scopes: external_exports.array(external_exports.string()).optional()
+}).strict();
+var youtubeCaptions = external_exports.object({
+  file: external_exports.string().min(1),
+  bytes: external_exports.number().int().positive().safe(),
+  sha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  language: external_exports.string().regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/),
+  name: external_exports.string().max(150),
+  status: external_exports.enum(["pending", "uploaded"]),
+  captionId: external_exports.string().min(1).max(512).nullable()
+}).strict();
+var youtubeThumbnail = external_exports.object({
+  file: external_exports.string().min(1),
+  bytes: external_exports.number().int().positive().safe(),
+  sha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  type: external_exports.enum(["image/jpeg", "image/png"]),
+  status: external_exports.enum(["pending", "uploaded"])
+}).strict();
+var youtubeJob = external_exports.object({
+  id: external_exports.uuid(),
+  file: external_exports.string().min(1),
+  bytes: external_exports.number().int().positive().safe(),
+  sha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  clientId: external_exports.string().min(1),
+  channelId: external_exports.string().min(1),
+  metadata: youtubeMetadata,
+  status: external_exports.enum(["uploading", "interrupted", "completed", "expired"]),
+  sessionUrl: external_exports.string().nullable(),
+  bytesUploaded: external_exports.number().int().nonnegative(),
+  youtubeId: external_exports.string().regex(/^[a-zA-Z0-9_-]{11}$/).nullable(),
+  privacy: external_exports.enum(["private", "unlisted", "public"]),
+  createdAt: external_exports.number(),
+  updatedAt: external_exports.number(),
+  captions: youtubeCaptions.optional(),
+  thumbnail: youtubeThumbnail.optional()
+}).strict();
+var youtubeDirectory = () => join8(dirname6(credentialsPath()), "youtube");
+var credentialFile = () => join8(youtubeDirectory(), "credentials.json");
+function jobFile(id2) {
+  if (!external_exports.uuid().safeParse(id2).success) throw new Error("Use an upload ID returned by animaguru youtube uploads list.");
+  return join8(youtubeDirectory(), "uploads", `${id2}.json`);
+}
+async function privateDirectory(directory) {
+  await mkdir7(directory, { recursive: true, mode: 448 });
+  const info = await lstat(directory);
+  if (info.isSymbolicLink() || !info.isDirectory()) throw new Error("YouTube configuration must use a real directory.");
+  await chmod3(directory, 448);
+}
+async function existingDirectory(directory) {
+  try {
+    const info = await lstat(directory);
+    if (info.isSymbolicLink() || !info.isDirectory()) throw new Error("YouTube configuration must use a real directory.");
+    return true;
+  } catch (error62) {
+    if (error62.code === "ENOENT") return false;
+    throw error62;
+  }
+}
+async function readPrivate(file2) {
+  try {
+    if (!await existingDirectory(youtubeDirectory()) || !await existingDirectory(dirname6(file2))) return null;
+    const info = await lstat(file2);
+    if (info.isSymbolicLink() || !info.isFile() || info.size > 65536) throw new Error("Invalid local YouTube state file.");
+    await chmod3(file2, 384);
+    return JSON.parse(await readFile9(file2, "utf8"));
+  } catch (error62) {
+    if (error62.code === "ENOENT") return null;
+    throw new Error("Cannot read local YouTube state. Check your AnimaGuru configuration directory.");
+  }
+}
+async function writePrivate(file2, value) {
+  await privateDirectory(youtubeDirectory());
+  await privateDirectory(dirname6(file2));
+  const temporary = `${file2}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile8(temporary, JSON.stringify(value) + "\n", { flag: "wx", mode: 384 });
+    await chmod3(temporary, 384);
+    await rename4(temporary, file2);
+  } finally {
+    await unlink(temporary).catch(() => {
+    });
+  }
+}
+async function readYouTubeCredentials() {
+  const value = await readPrivate(credentialFile());
+  if (value === null) return null;
+  const parsed = youtubeCredentials.safeParse(value);
+  if (!parsed.success) throw new Error("Invalid saved YouTube credentials. Run youtube auth logout, then login again.");
+  return parsed.data;
+}
+var saveYouTubeCredentials = (value) => writePrivate(credentialFile(), youtubeCredentials.parse(value));
+var saveYouTubeJob = (value) => writePrivate(jobFile(value.id), youtubeJob.parse(value));
+async function readYouTubeJob(id2) {
+  const parsed = youtubeJob.safeParse(await readPrivate(jobFile(id2)));
+  if (!parsed.success || parsed.data.id !== id2) throw new Error("Upload not found or local upload state is invalid.");
+  return parsed.data;
+}
+function youtubeJobSummary(job) {
+  return { id: job.id, file: job.file, title: job.metadata.title, channelId: job.channelId, status: job.status, bytes: job.bytes, bytesUploaded: job.bytesUploaded, privacy: job.privacy, youtubeId: job.youtubeId, url: job.youtubeId ? `https://www.youtube.com/watch?v=${job.youtubeId}` : null, createdAt: job.createdAt, captions: job.captions ? { file: job.captions.file, language: job.captions.language, name: job.captions.name, status: job.captions.status } : null, thumbnail: job.thumbnail ? { file: job.thumbnail.file, status: job.thumbnail.status } : null };
+}
+async function localYouTubeJobs() {
+  const directory = join8(youtubeDirectory(), "uploads");
+  if (!await existingDirectory(directory)) return [];
+  let files;
+  try {
+    files = await readdir3(directory);
+  } catch (error62) {
+    if (error62.code === "ENOENT") return [];
+    throw error62;
+  }
+  const jobs = [];
+  for (const file2 of files.filter((name) => name.endsWith(".json") && external_exports.uuid().safeParse(name.slice(0, -5)).success)) {
+    const job = await readYouTubeJob(file2.slice(0, -5));
+    if (job.updatedAt < Date.now() - 30 * 864e5) await unlink(jobFile(job.id));
+    else jobs.push(job);
+  }
+  return jobs.sort((a, b) => b.createdAt - a.createdAt);
+}
+async function clearYouTubeData() {
+  await unlink(credentialFile()).catch((error62) => {
+    if (error62.code !== "ENOENT") throw error62;
+  });
+  if (!await existingDirectory(join8(youtubeDirectory(), "uploads"))) return;
+  let files;
+  try {
+    files = await readdir3(join8(youtubeDirectory(), "uploads"));
+  } catch (error62) {
+    if (error62.code === "ENOENT") return;
+    throw error62;
+  }
+  for (const file2 of files.filter((name) => name.endsWith(".json") && external_exports.uuid().safeParse(name.slice(0, -5)).success)) await unlink(jobFile(file2.slice(0, -5)));
+}
+async function withYouTubeLock(operation) {
+  await privateDirectory(youtubeDirectory());
+  const file2 = join8(youtubeDirectory(), "operation.lock");
+  const lock = await open4(file2, "wx", 384).catch((error62) => {
+    if (error62.code === "EEXIST") throw new Error(`Another YouTube command is running. If a previous command was killed, verify it has stopped before removing ${file2}.`);
+    throw error62;
+  });
+  try {
+    await lock.writeFile(String(process.pid));
+    return await operation();
+  } finally {
+    await lock.close();
+    await unlink(file2);
+  }
+}
+
+// cli/src/youtube-auth.ts
+var YOUTUBE_SCOPES = ["https://www.googleapis.com/auth/youtube.upload", "https://www.googleapis.com/auth/youtube.readonly"];
+var YOUTUBE_CAPTION_SCOPE = "https://www.googleapis.com/auth/youtube.force-ssl";
+var canAddCaptions = (credentials) => credentials.scopes?.includes(YOUTUBE_CAPTION_SCOPE) ?? false;
+var YouTubeError = class extends Error {
+  constructor(message, retryable = false, expired = false, reason) {
+    super(message);
+    this.retryable = retryable;
+    this.expired = expired;
+    this.reason = reason;
+  }
+  retryable;
+  expired;
+  reason;
+};
+async function googleJson(response) {
+  const reader = response.body?.getReader();
+  if (!reader) return {};
+  const buffers = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { value: value2, done } = await reader.read();
+      if (done) break;
+      size += value2.length;
+      if (size > 65536) throw new Error();
+      buffers.push(value2);
+    }
+    const value = JSON.parse(Buffer.concat(buffers).toString("utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+  }
+}
+async function providerError(response) {
+  const body = await googleJson(response);
+  const error62 = body.error;
+  const raw = typeof error62 === "object" ? error62?.errors?.[0]?.reason : error62;
+  const reason = typeof raw === "string" && /^[A-Za-z_]{1,64}$/.test(raw) ? raw : void 0;
+  if (reason === "invalid_grant" || response.status === 401) return new YouTubeError("YouTube authorization expired or was revoked. Run youtube auth login again.");
+  if (["quotaExceeded", "dailyLimitExceeded", "uploadLimitExceeded"].includes(reason ?? "")) return new YouTubeError("YouTube upload quota exceeded. Resume this upload after your quota resets.");
+  if (reason === "captionExists") return new YouTubeError("The video already has a caption track with this language and name.", false, false, reason);
+  if (reason === "videoNotFound") return new YouTubeError("YouTube cannot find the uploaded video yet.", true, false, reason);
+  if (reason === "invalidImage") return new YouTubeError("YouTube rejected the thumbnail image.", false, false, reason);
+  if (reason === "invalidMetadata") return new YouTubeError("YouTube rejected the caption language or track name.", false, false, reason);
+  if ([404, 410].includes(response.status)) return new YouTubeError("YouTube upload session expired. Inspect your channel before starting a new upload.", false, true);
+  if (response.status === 403) return new YouTubeError("YouTube denied this request. Check channel permissions and your Google project's YouTube API configuration.", false, false, reason);
+  return new YouTubeError(`YouTube request failed (${response.status}${reason ? `: ${reason}` : ""}).`, response.status === 429 || response.status >= 500, false, reason);
+}
+async function googleFetch(url2, init, signal) {
+  signal?.throwIfAborted();
+  try {
+    return await fetch(url2, { ...init, redirect: "manual", signal: AbortSignal.any([AbortSignal.timeout(18e4), ...signal ? [signal] : []]) });
+  } catch {
+    signal?.throwIfAborted();
+    throw new YouTubeError("YouTube connection interrupted.", true);
+  }
+}
+async function tokenRequest(client, params, signal) {
+  const response = await googleFetch("https://oauth2.googleapis.com/token", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_id: client.clientId, ...client.clientSecret ? { client_secret: client.clientSecret } : {}, ...params }) }, signal);
+  if (!response.ok) {
+    const failure2 = await providerError(response);
+    if (failure2.message.includes("authorization expired")) await clearYouTubeData();
+    throw failure2;
+  }
+  return googleJson(response);
+}
+async function accessToken(credentials, signal, force = false) {
+  if (!force && credentials.expiresAt > Date.now() + 6e4) return credentials.accessToken;
+  const body = await tokenRequest(credentials, { grant_type: "refresh_token", refresh_token: credentials.refreshToken }, signal);
+  const scopes = typeof body.scope === "string" ? body.scope.split(" ") : null;
+  if (scopes && YOUTUBE_SCOPES.some((scope) => !scopes.includes(scope))) {
+    await clearYouTubeData();
+    throw new YouTubeError("YouTube permissions changed. Run youtube auth login again.");
+  }
+  if (typeof body.access_token !== "string" || typeof body.expires_in !== "number" || body.expires_in <= 0) throw new YouTubeError("Google returned an invalid authorization response.");
+  if (scopes) credentials.scopes = scopes;
+  credentials.accessToken = body.access_token;
+  credentials.expiresAt = Date.now() + body.expires_in * 1e3;
+  if (typeof body.refresh_token === "string") credentials.refreshToken = body.refresh_token;
+  await saveYouTubeCredentials(credentials);
+  return credentials.accessToken;
+}
+async function youtubeRequest(credentials, url2, init = {}, signal) {
+  const send = (token) => googleFetch(url2, { ...init, headers: { ...init.headers, Authorization: `Bearer ${token}` } }, signal);
+  let response = await send(await accessToken(credentials, signal));
+  if (response.status === 401) {
+    await response.body?.cancel();
+    response = await send(await accessToken(credentials, signal, true));
+  }
+  if (!response.ok && response.status !== 308) throw await providerError(response);
+  return response;
+}
+async function channelFor(credentials, signal) {
+  const response = await youtubeRequest(credentials, "https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true&fields=items(id,snippet(title))", {}, signal);
+  const body = await googleJson(response);
+  const items = body.items;
+  if (!Array.isArray(items) || items.length !== 1 || typeof items[0]?.id !== "string" || typeof items[0]?.snippet?.title !== "string") throw new YouTubeError("Choose a Google account with one YouTube channel in the authorization screen.");
+  return { id: items[0].id, title: items[0].snippet.title };
+}
+async function connectedYouTube(signal) {
+  const credentials = await readYouTubeCredentials();
+  if (!credentials) throw new Error("Connect your channel with animaguru youtube auth login --client-file PATH --yes.");
+  if (credentials.checkedAt < Date.now() - 864e5) await accessToken(credentials, signal, true);
+  const channel = await channelFor(credentials, signal);
+  if (channel.id !== credentials.channelId) throw new Error("The connected YouTube channel changed. Disconnect and reconnect before uploading.");
+  credentials.channelTitle = channel.title;
+  credentials.checkedAt = Date.now();
+  await saveYouTubeCredentials(credentials);
+  return credentials;
+}
+async function revoke(token, signal) {
+  try {
+    const response = await googleFetch("https://oauth2.googleapis.com/revoke", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ token }) }, signal);
+    await response.body?.cancel();
+    return response.ok || response.status === 400;
+  } catch {
+    return false;
+  }
+}
+async function youtubeLogin(options) {
+  if (!options.yes) throw new Error("Pass --yes to accept YouTube's Terms of Service and authorize saving YouTube credentials locally. Review https://www.youtube.com/t/terms and https://policies.google.com/privacy first.");
+  const seconds2 = options.timeout ?? 300;
+  if (!Number.isFinite(seconds2) || seconds2 < 1 || seconds2 > 600) throw new Error("Use an authorization timeout between 1 and 600 seconds.");
+  const requested = options.captions ? [...YOUTUBE_SCOPES, YOUTUBE_CAPTION_SCOPE] : YOUTUBE_SCOPES;
+  return withYouTubeLock(async () => {
+    const existing = await readYouTubeCredentials();
+    if (existing && options.captions && !canAddCaptions(existing)) throw new Error("A YouTube channel is already connected without caption permission. Run youtube auth logout --yes, then youtube auth login --captions.");
+    if (existing) throw new Error("A YouTube channel is already connected. Run youtube auth logout --yes before switching channels.");
+    const file2 = options["client-file"];
+    const info = await stat3(file2);
+    if (!info.isFile() || info.size > 65536) throw new Error("Use Google's downloaded Desktop app OAuth client JSON.");
+    let installed;
+    try {
+      installed = JSON.parse(await readFile10(file2, "utf8")).installed;
+    } catch {
+    }
+    if (!installed || typeof installed.client_id !== "string" || !installed.client_id.endsWith(".apps.googleusercontent.com") || installed.client_secret !== void 0 && typeof installed.client_secret !== "string") throw new Error("Use Google's Desktop app OAuth client JSON (installed), not a web client or API key.");
+    const client = { clientId: installed.client_id, ...typeof installed.client_secret === "string" ? { clientSecret: installed.client_secret } : {} };
+    const state = randomBytes(32).toString("base64url");
+    const verifier = randomBytes(32).toString("base64url");
+    let receive;
+    let fail;
+    let used = false;
+    const callback = new Promise((resolve12, reject) => {
+      receive = resolve12;
+      fail = reject;
+    });
+    void callback.catch(() => {
+    });
+    let redirectUri = "";
+    const server = createServer((request, response) => {
+      response.setHeader("Cache-Control", "no-store");
+      response.setHeader("Referrer-Policy", "no-referrer");
+      response.setHeader("Content-Type", "text/plain; charset=UTF-8");
+      response.setHeader("Content-Security-Policy", "default-src 'none'");
+      let url2;
+      try {
+        url2 = new URL(request.url ?? "/", redirectUri);
+      } catch {
+        response.writeHead(400).end("Invalid request.");
+        return;
+      }
+      if (request.method !== "GET" || request.headers.host !== new URL(redirectUri).host || url2.pathname !== "/oauth2callback" || (request.url?.length ?? 0) > 8192) {
+        response.writeHead(404).end("Not found.");
+        return;
+      }
+      const returnedState = Buffer.from(url2.searchParams.get("state") ?? "");
+      const expectedState = Buffer.from(state);
+      if (used || returnedState.length !== expectedState.length || !timingSafeEqual(returnedState, expectedState)) {
+        response.writeHead(400).end("Invalid authorization state.");
+        return;
+      }
+      used = true;
+      const code = url2.searchParams.get("code");
+      if (url2.searchParams.has("error") || !code || code.length > 4096) {
+        response.writeHead(400).end("Authorization cancelled. Return to your terminal.");
+        fail(new Error("YouTube authorization cancelled."));
+        return;
+      }
+      response.end("Authorization received. Return to your AnimaGuru terminal.");
+      receive(code);
+    });
+    await new Promise((resolve12, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", resolve12);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("Cannot open the local YouTube authorization listener.");
+    redirectUri = `http://127.0.0.1:${address.port}/oauth2callback`;
+    const timer = setTimeout(() => fail(new Error("YouTube authorization timed out. Run login again.")), seconds2 * 1e3);
+    const abort = () => fail(new Error("YouTube authorization cancelled."));
+    options.signal?.addEventListener("abort", abort, { once: true });
+    let token;
+    try {
+      options.signal?.throwIfAborted();
+      const url2 = new URL("https://accounts.google.com/o/oauth2/v2/auth");
+      url2.search = new URLSearchParams({ client_id: client.clientId, redirect_uri: redirectUri, response_type: "code", scope: requested.join(" "), state, code_challenge: createHash3("sha256").update(verifier).digest("base64url"), code_challenge_method: "S256", access_type: "offline", prompt: "consent select_account" }).toString();
+      options.log?.("YouTube authorization stays on this machine. Tokens and upload receipts are saved in owner-only local files. Video bytes go directly to Google. Google privacy: https://policies.google.com/privacy \xB7 YouTube terms: https://www.youtube.com/t/terms");
+      options.log?.(`Open ${url2.href}`);
+      if (options.browser !== false) await options.openBrowser?.(url2.href);
+      const body = await tokenRequest(client, { grant_type: "authorization_code", code: await callback, code_verifier: verifier, redirect_uri: redirectUri }, options.signal);
+      token = typeof body.refresh_token === "string" ? body.refresh_token : typeof body.access_token === "string" ? body.access_token : void 0;
+      const scopes = typeof body.scope === "string" ? body.scope.split(" ") : [];
+      if (requested.some((scope) => !scopes.includes(scope))) throw new Error(options.captions ? "Approve all requested YouTube permissions, including captions, or log in without --captions." : "Approve both YouTube permissions to connect this channel.");
+      if (typeof body.access_token !== "string" || typeof body.refresh_token !== "string" || typeof body.expires_in !== "number" || body.expires_in <= 0) throw new Error("Google did not grant offline access. Reconnect and approve access.");
+      const now = Date.now();
+      const credentials = { ...client, accessToken: body.access_token, refreshToken: body.refresh_token, expiresAt: now + body.expires_in * 1e3, channelId: "pending", channelTitle: "pending", connectedAt: now, checkedAt: now, scopes };
+      const channel = await channelFor(credentials, options.signal);
+      credentials.channelId = channel.id;
+      credentials.channelTitle = channel.title;
+      await saveYouTubeCredentials(credentials);
+      return { authenticated: true, channelId: channel.id, channelTitle: channel.title, captions: canAddCaptions(credentials) };
+    } catch (error62) {
+      if (token) await revoke(token);
+      throw error62;
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", abort);
+      server.closeAllConnections();
+      await new Promise((resolve12) => server.close(() => resolve12()));
+    }
+  });
+}
+async function youtubeStatus(options = {}) {
+  return withYouTubeLock(async () => {
+    if (!await readYouTubeCredentials()) return { authenticated: false };
+    const credentials = await connectedYouTube(options.signal);
+    return { authenticated: true, channelId: credentials.channelId, channelTitle: credentials.channelTitle, captions: canAddCaptions(credentials) };
+  });
+}
+async function youtubeLogout(options) {
+  if (!options.yes) throw new Error("Pass --yes to revoke YouTube authorization and remove local credentials and upload receipts.");
+  return withYouTubeLock(async () => {
+    let credentials = null;
+    let readable = true;
+    try {
+      credentials = await readYouTubeCredentials();
+    } catch {
+      readable = false;
+    }
+    const revoked = readable && (credentials ? await revoke(credentials.refreshToken, options.signal) : true);
+    await clearYouTubeData();
+    if (!revoked) options.log?.("Local YouTube data removed. Also revoke access at https://security.google.com/settings/security/permissions because Google could not confirm revocation.");
+    return { authenticated: false, revoked };
+  });
+}
+
+// cli/src/youtube-upload.ts
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import { open as open5, readFile as readFile11, stat as stat4 } from "node:fs/promises";
+import { basename as basename5, join as join9, resolve as resolve10 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+var YOUTUBE_CHUNK_BYTES = 8 * 1024 * 1024;
+function safeYouTubeSession(value) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    throw new YouTubeError("Google returned an invalid upload session.");
+  }
+  if (url2.protocol !== "https:" || !["www.googleapis.com", "youtube.googleapis.com"].includes(url2.hostname) || url2.port || url2.username || url2.password || url2.hash || !/^\/upload\/youtube\/v3\/videos\/?$/.test(url2.pathname) || !url2.searchParams.get("upload_id")) throw new YouTubeError("Google returned an invalid upload session.");
+  return url2.href;
+}
+async function inspectMp4(file2, signal) {
+  const handle = await open5(file2, "r");
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || !file2.toLowerCase().endsWith(".mp4") || info.size < 12 || info.size > 256 * 1024 ** 3) throw new Error("Choose an exported .mp4 file up to 256 GiB. Export an HTML5 animation with npm run export:mp4 first.");
+    const header = Buffer.alloc(12);
+    await handle.read(header, 0, header.length, 0);
+    if (header.toString("ascii", 4, 8) !== "ftyp") throw new Error("Use a valid MP4 file.");
+    const hash2 = createHash4("sha256");
+    for await (const buffer of handle.createReadStream({ start: 0, autoClose: false, signal })) hash2.update(buffer);
+    const fingerprint = (value) => `${value.dev}:${value.ino}:${value.size}:${value.mtimeMs}:${value.ctimeMs}`;
+    const check2 = async () => {
+      signal?.throwIfAborted();
+      if (fingerprint(await handle.stat()) !== fingerprint(info)) throw new Error("The MP4 changed during upload. Restore the original export before resuming.");
+    };
+    await check2();
+    return { handle, bytes: info.size, sha256: hash2.digest("hex"), check: check2 };
+  } catch (error62) {
+    await handle.close();
+    throw error62;
+  }
+}
+var readCaptionFile = (file2) => readSubtitleFile(file2, 5 * 1024 * 1024);
+async function planCaptions(root, mp4, options, fallbackLanguage) {
+  const choice = options.captions ?? "auto";
+  const found = await subtitleFile(root, mp4, choice, [".srt", ".vtt"]);
+  if (!found) return null;
+  const { file: file2 } = found;
+  const { content, sha256, language: header } = await readCaptionFile(file2);
+  const language = options["caption-language"] ?? header ?? fallbackLanguage;
+  const name = options["caption-name"] ?? "";
+  const plan = youtubeCaptions.safeParse({ file: file2, bytes: content.length, sha256, language, name, status: "pending", captionId: null });
+  if (!plan.success) throw new Error("Pass --caption-language with the subtitles' language code, such as en or tr, and a --caption-name up to 150 characters.");
+  return { file: file2, bytes: content.length, sha256, language: plan.data.language, name, explicit: choice !== "auto" };
+}
+async function readThumbnail(file2) {
+  let info;
+  try {
+    info = await stat4(file2);
+  } catch {
+    throw new Error(`Cannot read the thumbnail ${file2}.`);
+  }
+  if (!info.isFile() || info.size < 8 || info.size > 2 * 1024 * 1024) throw new Error("Use a JPEG or PNG thumbnail up to 2 MiB, such as the one npm run export:mp4 saves beside the MP4.");
+  const content = await readFile11(file2);
+  const type = content[0] === 255 && content[1] === 216 && content[2] === 255 ? "image/jpeg" : content.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) ? "image/png" : null;
+  if (!type) throw new Error("Use a JPEG or PNG thumbnail.");
+  return { content, type, sha256: createHash4("sha256").update(content).digest("hex") };
+}
+async function planThumbnail(root, mp4, choice = "auto") {
+  if (choice === "none") return null;
+  let file2 = choice === "auto" ? void 0 : resolve10(root, choice);
+  if (!file2) {
+    for (const extension of [".jpg", ".jpeg", ".png"]) {
+      const candidate = mp4.replace(/\.mp4$/i, extension);
+      if (await stat4(candidate).then((info) => info.isFile(), () => false)) {
+        file2 = candidate;
+        break;
+      }
+    }
+    if (!file2) return null;
+  }
+  const { content, type, sha256 } = await readThumbnail(file2);
+  return { file: file2, bytes: content.length, sha256, type, status: "pending" };
+}
+async function addThumbnail(credentials, job, options) {
+  const thumbnail = job.thumbnail;
+  if (!thumbnail || thumbnail.status === "uploaded" || !job.youtubeId) return null;
+  try {
+    const { content, sha256 } = await readThumbnail(thumbnail.file);
+    if (sha256 !== thumbnail.sha256) throw new Error("The thumbnail changed after this upload started; restore it first.");
+    for (let attempts = 0; ; attempts++) {
+      try {
+        const response = await youtubeRequest(credentials, `https://www.googleapis.com/upload/youtube/v3/thumbnails/set?videoId=${encodeURIComponent(job.youtubeId)}&uploadType=media`, { method: "POST", headers: { "Content-Type": thumbnail.type }, body: new Uint8Array(content) }, options.signal);
+        const body = await googleJson(response);
+        if (!Array.isArray(body.items) || !body.items.length) throw new YouTubeError("Google returned an invalid thumbnail confirmation. Check the video in YouTube Studio.");
+        break;
+      } catch (error62) {
+        if (!(error62 instanceof YouTubeError)) throw error62;
+        if (error62.reason === "forbidden") throw new Error("YouTube did not allow a custom thumbnail. Verify the channel at https://www.youtube.com/verify, then resume.");
+        if (options.signal?.aborted || !error62.retryable || attempts >= 2) throw error62;
+        await delay2(1e3 * 2 ** attempts, void 0, { signal: options.signal });
+      }
+    }
+    thumbnail.status = "uploaded";
+    job.updatedAt = Date.now();
+    await saveYouTubeJob(job);
+    options.log?.(`Set the thumbnail from ${thumbnail.file}.`);
+    return null;
+  } catch (error62) {
+    if (options.signal?.aborted) throw error62;
+    const message = error62 instanceof Error ? error62.message : String(error62);
+    options.log?.(`The video is on YouTube, but its thumbnail was not set: ${message} Retry with animaguru youtube uploads resume ${job.id} --yes, or set ${thumbnail.file} in YouTube Studio.`);
+    return message;
+  }
+}
+async function finishUpload(credentials, job, options) {
+  const summary = await addCaptions(credentials, job, options);
+  const thumbnailError = await addThumbnail(credentials, job, options);
+  return { ...summary, ...youtubeJobSummary(job), ...thumbnailError ? { thumbnailError } : {} };
+}
+function languageName(code) {
+  try {
+    return new Intl.DisplayNames([code], { type: "language" }).of(code) ?? code;
+  } catch {
+    return code;
+  }
+}
+async function insertCaption(credentials, videoId, language, name, content, signal) {
+  const boundary = `animaguru-${randomUUID3()}`;
+  const metadata = JSON.stringify({ snippet: { videoId, language, name, isDraft: false } });
+  const body = Buffer.concat([Buffer.from(`--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${metadata}\r
+--${boundary}\r
+Content-Type: application/octet-stream\r
+\r
+`), content, Buffer.from(`\r
+--${boundary}--\r
+`)]);
+  const response = await youtubeRequest(credentials, "https://www.googleapis.com/upload/youtube/v3/captions?uploadType=multipart&part=snippet", { method: "POST", headers: { "Content-Type": `multipart/related; boundary=${boundary}` }, body: new Uint8Array(body) }, signal);
+  const caption = await googleJson(response);
+  const snippet = caption.snippet;
+  if (typeof caption.id !== "string" || !caption.id || caption.id.length > 512 || snippet?.videoId !== videoId) throw new YouTubeError("Google returned an invalid caption confirmation. Check the video's subtitles in YouTube Studio.");
+  return caption.id;
+}
+async function addCaptions(credentials, job, options) {
+  const captions = job.captions;
+  if (!captions || captions.status === "uploaded" || !job.youtubeId) return youtubeJobSummary(job);
+  try {
+    if (!canAddCaptions(credentials)) throw new Error("The channel was connected without caption permission; reconnect with youtube auth login --captions.");
+    const { content, sha256 } = await readCaptionFile(captions.file);
+    if (sha256 !== captions.sha256) throw new Error("The subtitle file changed after this upload started; restore it first.");
+    const names = captions.name ? [captions.name] : ["", languageName(captions.language)];
+    let index = 0;
+    let attempts = 0;
+    let captionId = null;
+    while (true) {
+      try {
+        captionId = await insertCaption(credentials, job.youtubeId, captions.language, names[index], content, options.signal);
+        break;
+      } catch (error62) {
+        if (!(error62 instanceof YouTubeError)) throw error62;
+        if (error62.reason === "invalidMetadata" && index + 1 < names.length) {
+          index++;
+          continue;
+        }
+        if (error62.reason === "captionExists") {
+          options.log?.(`YouTube already has a ${captions.language} caption track${names[index] ? ` named ${names[index]}` : ""} on this video.`);
+          break;
+        }
+        if (options.signal?.aborted || !error62.retryable || attempts >= 2) throw error62;
+        await delay2(1e3 * 2 ** attempts++, void 0, { signal: options.signal });
+      }
+    }
+    captions.name = names[index];
+    captions.status = "uploaded";
+    captions.captionId = captionId;
+    job.updatedAt = Date.now();
+    await saveYouTubeJob(job);
+    options.log?.(`Added ${captions.language} captions from ${captions.file}.`);
+    return youtubeJobSummary(job);
+  } catch (error62) {
+    if (options.signal?.aborted) throw error62;
+    const message = error62 instanceof Error ? error62.message : String(error62);
+    options.log?.(`The video is on YouTube, but its captions were not added: ${message} Retry with animaguru youtube uploads resume ${job.id} --yes, or add ${captions.file} in YouTube Studio.`);
+    return { ...youtubeJobSummary(job), captionsError: message };
+  }
+}
+function receivedBytes(response, total) {
+  const range = response.headers.get("Range");
+  if (!range) return 0;
+  const match = /^bytes=0-(\d+)$/.exec(range);
+  const bytes = match ? Number(match[1]) + 1 : NaN;
+  if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > total) throw new YouTubeError("Google returned invalid upload progress.");
+  return bytes;
+}
+async function completed(job, response) {
+  const body = await googleJson(response);
+  const snippet = body.snippet;
+  const status = body.status;
+  if (typeof body.id !== "string" || !/^[a-zA-Z0-9_-]{11}$/.test(body.id) || snippet?.channelId !== job.channelId || !["private", "unlisted", "public"].includes(status?.privacyStatus ?? "")) throw new YouTubeError("Google returned an invalid video confirmation. Inspect YouTube Studio before trying a new upload.");
+  job.youtubeId = body.id;
+  job.privacy = status.privacyStatus;
+  job.bytesUploaded = job.bytes;
+  job.status = "completed";
+  job.sessionUrl = null;
+  job.updatedAt = Date.now();
+  await saveYouTubeJob(job);
+  return youtubeJobSummary(job);
+}
+async function transfer(credentials, job, source, options) {
+  const url2 = safeYouTubeSession(job.sessionUrl);
+  let attempts = 0;
+  let stalled = 0;
+  try {
+    while (true) {
+      await source.check();
+      try {
+        const probe = await youtubeRequest(credentials, url2, { method: "PUT", headers: { "Content-Range": `bytes */${job.bytes}`, "Content-Length": "0" }, body: Buffer.alloc(0) }, options.signal);
+        if (probe.ok) return await completed(job, probe);
+        const offset = receivedBytes(probe, job.bytes);
+        await probe.body?.cancel();
+        if (offset >= job.bytes) throw new YouTubeError("YouTube has all bytes but has not confirmed the video. Resume this upload later.", true);
+        const bytes = Buffer.alloc(Math.min(YOUTUBE_CHUNK_BYTES, job.bytes - offset));
+        const read2 = await source.handle.read(bytes, 0, bytes.length, offset);
+        if (read2.bytesRead !== bytes.length) throw new Error("The MP4 changed during upload. Restore it before resuming.");
+        await source.check();
+        const response = await youtubeRequest(credentials, url2, { method: "PUT", headers: { "Content-Type": "video/mp4", "Content-Length": String(bytes.length), "Content-Range": `bytes ${offset}-${offset + bytes.length - 1}/${job.bytes}` }, body: new Uint8Array(bytes) }, options.signal);
+        if (response.ok) return await completed(job, response);
+        const uploaded = receivedBytes(response, job.bytes);
+        await response.body?.cancel();
+        if (uploaded <= offset || uploaded > offset + bytes.length) throw new YouTubeError("Google returned invalid upload progress.", true);
+        stalled = uploaded <= job.bytesUploaded ? stalled + 1 : 0;
+        if (stalled > 3) throw new YouTubeError("YouTube upload progress stalled. Resume this upload later.");
+        job.bytesUploaded = uploaded;
+        job.status = "uploading";
+        job.updatedAt = Date.now();
+        await saveYouTubeJob(job);
+        options.log?.(`YouTube upload ${job.id}: ${Math.floor(uploaded / job.bytes * 100)}% (${uploaded}/${job.bytes} bytes)`);
+        attempts = 0;
+      } catch (error62) {
+        if (options.signal?.aborted || !(error62 instanceof YouTubeError) || !error62.retryable || attempts >= 3) throw error62;
+        options.log?.("YouTube transfer interrupted. Checking the saved upload before retrying\u2026");
+        await delay2(1e3 * 2 ** attempts++, void 0, { signal: options.signal });
+      }
+    }
+  } catch (error62) {
+    job.status = error62 instanceof YouTubeError && error62.expired ? "expired" : "interrupted";
+    job.updatedAt = Date.now();
+    if (await readYouTubeCredentials()) await saveYouTubeJob(job);
+    options.log?.(`Upload ID: ${job.id}. Inspect with animaguru youtube uploads list; resume with animaguru youtube uploads resume ${job.id} --yes. Check YouTube Studio before starting a new upload.`);
+    throw error62;
+  }
+}
+async function uploadYouTube(options) {
+  if (!options.yes && !options["dry-run"]) throw new Error("Pass --yes to authorize the YouTube upload, or --dry-run to inspect it locally.");
+  if (!["yes", "no"].includes(options["made-for-kids"]) || !["yes", "no"].includes(options["synthetic-media"])) throw new Error("Set --made-for-kids yes|no and --synthetic-media yes|no explicitly.");
+  const root = resolve10(options.directory ?? ".");
+  const file2 = resolve10(root, options.file);
+  const context = await localProject(root, options.animation);
+  let config2 = {};
+  try {
+    config2 = JSON.parse(await readFile11(join9(context.projectRoot, "film.config.json"), "utf8"));
+  } catch {
+  }
+  const receipt = await exportReceipt(file2);
+  const parsed = youtubeMetadata.safeParse({ title: options.title ?? receipt.title ?? config2.title ?? basename5(file2).replace(/\.mp4$/i, ""), description: options.description ?? "", privacy: options.privacy ?? "private", madeForKids: options["made-for-kids"] === "yes", syntheticMedia: options["synthetic-media"] === "yes" });
+  if (!parsed.success) throw new Error("Use a title of 1\u2013100 characters and a description up to 5,000 UTF-8 bytes, without < or >, and private, unlisted or public privacy.");
+  const metadata = parsed.data;
+  let captions = await planCaptions(root, file2, options, receipt.language ?? config2.language);
+  const thumbnail = await planThumbnail(root, file2, options.thumbnail);
+  const source = await inspectMp4(file2, options.signal);
+  try {
+    if (options["dry-run"]) return { dryRun: true, file: file2, bytes: source.bytes, sha256: source.sha256, channelId: options.channel ?? null, metadata, captions: captions && { file: captions.file, bytes: captions.bytes, language: captions.language, name: captions.name }, thumbnail: thumbnail && { file: thumbnail.file, bytes: thumbnail.bytes, type: thumbnail.type } };
+    return await withYouTubeLock(async () => {
+      const credentials = await connectedYouTube(options.signal);
+      if (options.channel && options.channel !== credentials.channelId) throw new Error("The requested channel does not match the connected YouTube channel.");
+      if (captions && !canAddCaptions(credentials)) {
+        if (captions.explicit) throw new Error("Adding captions needs YouTube caption permission. Run youtube auth logout --yes, then youtube auth login --captions, or pass --captions none.");
+        options.log?.(`Skipping ${captions.file}: the channel was connected without caption permission. Reconnect with youtube auth login --captions to add subtitles.`);
+        captions = null;
+      }
+      const pending = captions && { file: captions.file, bytes: captions.bytes, sha256: captions.sha256, language: captions.language, name: captions.name, status: "pending", captionId: null };
+      const jobs = (await localYouTubeJobs()).filter((job2) => job2.channelId === credentials.channelId && job2.sha256 === source.sha256);
+      if (jobs.some((job2) => ["uploading", "interrupted"].includes(job2.status))) throw new Error("This file has an unfinished upload. Use youtube uploads list and resume its ID instead of creating a duplicate.");
+      const previous = jobs.find((job2) => job2.status === "completed" && JSON.stringify(job2.metadata) === JSON.stringify(metadata));
+      if (previous) {
+        if (pending && previous.captions?.status !== "uploaded") previous.captions = pending;
+        else if (pending && previous.captions?.sha256 !== pending.sha256) options.log?.(`This video already has captions from ${previous.captions.file}. Replace them in YouTube Studio.`);
+        if (thumbnail && previous.thumbnail?.status !== "uploaded") previous.thumbnail = thumbnail;
+        else if (thumbnail && previous.thumbnail?.sha256 !== thumbnail.sha256) options.log?.(`This video already has the thumbnail from ${previous.thumbnail.file}. Replace it in YouTube Studio.`);
+        await saveYouTubeJob(previous);
+        return { ...await finishUpload(credentials, previous, options), alreadyUploaded: true };
+      }
+      await source.check();
+      options.log?.(`Uploading ${file2} to ${credentials.channelTitle} (${credentials.channelId}) with ${metadata.privacy} visibility${pending ? `, then adding ${pending.language} captions from ${pending.file}` : ""}${thumbnail ? `${pending ? " and" : ", then setting"} the thumbnail ${thumbnail.file}` : ""}. You confirm you have the rights to upload this video. YouTube terms: https://www.youtube.com/t/terms`);
+      const response = await youtubeRequest(credentials, "https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status&notifySubscribers=false", { method: "POST", headers: { "Content-Type": "application/json; charset=UTF-8", "X-Upload-Content-Length": String(source.bytes), "X-Upload-Content-Type": "video/mp4" }, body: JSON.stringify({ snippet: { title: metadata.title, description: metadata.description, categoryId: "22" }, status: { privacyStatus: metadata.privacy, selfDeclaredMadeForKids: metadata.madeForKids, containsSyntheticMedia: metadata.syntheticMedia } }) }, options.signal);
+      const location = response.headers.get("Location");
+      await response.body?.cancel();
+      if (!location) throw new YouTubeError("Google did not return an upload session. No video bytes were sent.");
+      const now = Date.now();
+      const job = { id: randomUUID3(), file: file2, bytes: source.bytes, sha256: source.sha256, clientId: credentials.clientId, channelId: credentials.channelId, metadata, status: "uploading", sessionUrl: safeYouTubeSession(location), bytesUploaded: 0, youtubeId: null, privacy: metadata.privacy, createdAt: now, updatedAt: now, ...pending ? { captions: pending } : {}, ...thumbnail ? { thumbnail } : {} };
+      await saveYouTubeJob(job);
+      options.log?.(`Upload ID: ${job.id}`);
+      await transfer(credentials, job, source, options);
+      return finishUpload(credentials, job, options);
+    });
+  } finally {
+    await source.handle.close();
+  }
+}
+async function resumeYouTube(id2, options) {
+  if (!options.yes) throw new Error("Pass --yes to resume the previously authorized YouTube upload with its saved destination and settings.");
+  return withYouTubeLock(async () => {
+    const job = await readYouTubeJob(id2);
+    if (job.status === "completed") {
+      if (job.captions?.status !== "pending" && job.thumbnail?.status !== "pending") return youtubeJobSummary(job);
+      const credentials = await connectedYouTube(options.signal);
+      if (credentials.channelId !== job.channelId) throw new Error("Connect the original YouTube channel before adding this video's captions or thumbnail.");
+      return finishUpload(credentials, job, options);
+    }
+    if (job.status === "expired" || !job.sessionUrl) throw new Error("This YouTube session expired. Inspect your channel before starting a new upload.");
+    safeYouTubeSession(job.sessionUrl);
+    const source = await inspectMp4(job.file, options.signal);
+    try {
+      if (source.bytes !== job.bytes || source.sha256 !== job.sha256) throw new Error("The MP4 differs from the original upload. Restore the original file before resuming.");
+      const credentials = await connectedYouTube(options.signal);
+      if (credentials.clientId !== job.clientId || credentials.channelId !== job.channelId) throw new Error("Connect the original Google client and YouTube channel before resuming.");
+      options.log?.(`Resuming ${job.id} to ${credentials.channelTitle} (${job.channelId}) with ${job.metadata.privacy} visibility.`);
+      await transfer(credentials, job, source, options);
+      return await finishUpload(credentials, job, options);
+    } finally {
+      await source.handle.close();
+    }
+  });
+}
+var listYouTubeUploads = () => withYouTubeLock(async () => ({ uploads: (await localYouTubeJobs()).map(youtubeJobSummary) }));
+
 // cli/src/commands.ts
 var assetModelIds = [...SPRITE_IMAGE_MODEL_IDS, ...SPRITE_VIDEO_MODEL_IDS, ...MUSIC_MODELS.map((m) => m.id), ...SPEECH_MODELS.map((m) => m.id), ...SFX_MODELS.map((m) => m.id)];
 var assetAuthorizationFlags = [
@@ -27478,17 +28425,38 @@ var workspaceQuery = async (client) => {
 async function openBrowser(url2) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "rundll32" : "xdg-open";
   const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url2] : [url2];
-  await new Promise((resolve10) => {
+  await new Promise((resolve12) => {
     const child = spawn3(command, args, { stdio: "ignore", detached: true });
-    child.once("error", () => resolve10());
+    child.once("error", () => resolve12());
     child.once("spawn", () => {
       child.unref();
-      resolve10();
+      resolve12();
     });
   });
 }
 function createCli() {
-  return new Crust("animaguru", { description: "Sprite and asset generation, video workspaces, and public or private video sharing. Successful commands output JSON. Paid jobs and sharing require --yes.", version: package_default.version }).add(defineCommand("init", { description: "Install or refresh the AnimaGuru agent skill in the current folder" }, (command) => command.action(async ({ stdout }) => out(stdout, await initializeSkill())))).add(defineCommand("templates", { description: "List video categories and available starter templates" }, (command) => command.action(({ stdout }) => out(stdout, listTemplates())))).command("create", (creation) => creation.args({ name: "name", type: "string", description: "Legacy standalone project folder; prefer create workspace NAME" }).action(async ({ args, stdout, stderr, signal }) => {
+  return new Crust("animaguru", { description: "Sprite and asset generation, video workspaces, video sharing, and direct local YouTube uploads. Successful commands output JSON. Paid jobs and uploads require --yes.", version: package_default.version }).command("youtube", (youtube) => youtube.command("auth", (auth) => auth.add(defineCommand("login", { description: "Connect a YouTube channel through Google; credentials stay on this computer" }, (command) => command.flags(
+    { name: "client-file", type: "string", required: true, env: { name: "ANIMAGURU_YOUTUBE_CLIENT_FILE" }, description: "Google Desktop app OAuth client JSON" },
+    { name: "browser", type: "boolean", default: true, description: "Open the system browser; --no-browser prints the URL" },
+    { name: "timeout", type: "number", default: 300, description: "Authorization timeout in seconds (1\u2013600)" },
+    { name: "captions", type: "boolean", description: "Also allow adding subtitle tracks; Google's youtube.force-ssl permission also lets the CLI manage your videos" },
+    { name: "yes", type: "boolean", description: "Accept YouTube terms and authorize local credential storage" }
+  ).action(async ({ flags, stdout, stderr, signal }) => out(stdout, await youtubeLogin({ ...flags, log: stderr, signal, openBrowser }))))).add(defineCommand("status", { description: "Verify and show the connected YouTube channel without exposing tokens" }, (command) => command.action(async ({ stdout, signal }) => out(stdout, await youtubeStatus({ signal }))))).add(defineCommand("logout", { description: "Revoke Google access and remove local YouTube credentials and receipts; videos remain" }, (command) => command.flags({ name: "yes", type: "boolean", description: "Authorize revocation and local data removal" }).action(async ({ flags, stdout, stderr, signal }) => out(stdout, await youtubeLogout({ ...flags, log: stderr, signal })))))).add(defineCommand("upload", { description: "Upload a local MP4 directly to your YouTube channel; no AnimaGuru server or sign-in" }, (command) => command.args({ name: "directory", type: "string", default: ".", description: "Project folder used for relative file paths and default title" }).flags(
+    { name: "file", type: "string", required: true, description: "Local exported MP4" },
+    { name: "animation", type: "string", description: "Animation in a multi-animation workspace" },
+    { name: "title", type: "string" },
+    { name: "description", type: "string" },
+    { name: "privacy", type: "string", choices: ["private", "unlisted", "public"], default: "private" },
+    { name: "made-for-kids", type: "string", required: true, choices: ["yes", "no"], description: "Your YouTube audience declaration" },
+    { name: "synthetic-media", type: "string", required: true, choices: ["yes", "no"], description: "Contains realistic altered or synthetic media; follow YouTube disclosure guidance" },
+    { name: "channel", type: "string", description: "Require this exact channel ID instead of relying on the saved connection" },
+    { name: "captions", type: "string", default: "auto", description: "Subtitle file (.srt or .vtt) to add after the upload; auto uses FILM.srt or FILM.vtt beside FILM.mp4; none skips" },
+    { name: "caption-language", type: "string", description: "Subtitle language code such as en or tr; defaults to the MP4's export receipt or film.config.json" },
+    { name: "caption-name", type: "string", description: "Track name in YouTube's subtitle menu; empty by default, like YouTube Studio uploads" },
+    { name: "thumbnail", type: "string", default: "auto", description: "JPEG or PNG thumbnail up to 2 MiB to set after the upload; auto uses FILM.jpg beside FILM.mp4; none skips" },
+    { name: "yes", type: "boolean", description: "Authorize sending this video, its subtitles and thumbnail to the selected channel and privacy; confirm upload rights" },
+    { name: "dry-run", type: "boolean", description: "Inspect MP4 and metadata locally without Google authorization or network calls" }
+  ).action(async ({ args, flags, stdout, stderr, signal }) => out(stdout, await uploadYouTube({ ...flags, directory: args.directory, log: stderr, signal }))))).command("uploads", (uploads) => uploads.add(defineCommand("list", { description: "List local upload receipts without tokens or session URLs" }, (command) => command.action(async ({ stdout }) => out(stdout, await listYouTubeUploads())))).add(defineCommand("resume", { description: "Resume the same local MP4 and Google upload session after an interruption" }, (command) => command.args({ name: "id", type: "string", required: true, description: "Upload ID returned by youtube uploads list" }).flags({ name: "yes", type: "boolean", description: "Authorize resuming the saved upload and visibility" }).action(async ({ args, flags, stdout, stderr, signal }) => out(stdout, await resumeYouTube(args.id, { ...flags, log: stderr, signal }))))))).add(defineCommand("init", { description: "Install or refresh the AnimaGuru agent skill in the current folder" }, (command) => command.action(async ({ stdout }) => out(stdout, await initializeSkill())))).add(defineCommand("templates", { description: "List video categories and available starter templates" }, (command) => command.action(({ stdout }) => out(stdout, listTemplates())))).command("create", (creation) => creation.args({ name: "name", type: "string", description: "Legacy standalone project folder; prefer create workspace NAME" }).action(async ({ args, stdout, stderr, signal }) => {
     if (!args.name) throw new Error("Use animaguru create workspace NAME, or animaguru create animation NAME inside a workspace.");
     out(stdout, await createVideoProject({ directory: args.name, log: stderr, signal }));
   }).add(defineCommand("workspace", { description: "Create a shared-brand workspace with one player, dependencies, skills and export toolchain" }, (command) => command.args({ name: "name", type: "string", required: true }).action(async ({ args, stdout, stderr, signal }) => out(stdout, await createWorkspace({ directory: args.name, log: stderr, signal }))))).add(defineCommand("animation", { description: "Add an animation to a workspace without copying shared runtime, dependencies or skills" }, (command) => command.args({ name: "name", type: "string", required: true }).flags({ name: "workspace", type: "string", description: "Workspace folder; otherwise finds it from the current directory" }).action(async ({ args, flags, stdout, stderr, signal }) => out(stdout, await createAnimation({ name: args.name, workspace: flags.workspace, log: stderr, signal })))))).add(defineCommand("submit", { description: "Upload a finished HTML5 animation or MP4 to AnimaGuru; private unless --visibility public" }, (command) => command.args({ name: "directory", type: "string", default: ".", description: "Video project folder; defaults to current folder" }).flags(
@@ -27500,6 +28468,8 @@ function createCli() {
     { name: "visibility", type: "string", choices: ["private", "public"], default: "private" },
     { name: "share", type: "string", description: "Comma-separated emails of verified AnimaGuru users (private videos)" },
     { name: "poster", type: "string", description: "PNG, JPEG or WebP cover image" },
+    { name: "subtitles", type: "string", default: "auto", description: "MP4 subtitle file (.vtt or .srt) the player shows over the picture; auto uses FILM.vtt or FILM.srt beside FILM.mp4; none skips" },
+    { name: "subtitle-language", type: "string", description: "Subtitle language code such as en or tr; defaults to the MP4's export receipt or film.config.json" },
     { name: "yes", type: "boolean", description: "Authorize upload and chosen sharing" },
     { name: "dry-run", type: "boolean", description: "Inspect locally without uploading" }
   ).action(async ({ args, flags, stdout, stderr, signal }) => out(stdout, await submitVideo(new Client(flags.url, signal), { ...flags, directory: args.directory, log: stderr, signal }))))).command("videos", (videos) => videos.add(defineCommand("list", { description: "List your videos, privately shared videos, or the public gallery" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }, { name: "scope", type: "string", choices: ["mine", "shared", "public"], default: "mine" }, { name: "page", type: "number", default: 1 }).action(async ({ flags, stdout, signal }) => out(stdout, await new Client(flags.url, signal).request(flags.scope === "public" ? `/api/videos?page=${flags.page}` : `/api/v1/videos?scope=${flags.scope}&page=${flags.page}`, { authenticated: flags.scope !== "public" }))))).add(defineCommand("get", { description: "Get a video's details or the state of your unfinished upload" }, (command) => command.args({ name: "id", type: "string", required: true }).flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }).action(async ({ args, flags, stdout, signal }) => out(stdout, await new Client(flags.url, signal).request(`/api/v1/videos/${encodeURIComponent(args.id)}`))))).add(defineCommand("complete", { description: "Retry completion of an already uploaded animation" }, (command) => command.args({ name: "id", type: "string", required: true }).flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }).action(async ({ args, flags, stdout, signal }) => out(stdout, await new Client(flags.url, signal).request(`/api/v1/videos/${encodeURIComponent(args.id)}/complete`, { method: "POST", timeout: 3e5 }))))).add(defineCommand("share", { description: "Replace a video's visibility and recipient list" }, (command) => command.args({ name: "id", type: "string", required: true }).flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }, { name: "visibility", type: "string", required: true, choices: ["private", "public"] }, { name: "share", type: "string" }, { name: "yes", type: "boolean", required: true }).action(async ({ args, flags, stdout, signal }) => {
@@ -27507,7 +28477,13 @@ function createCli() {
     const client = new Client(flags.url, signal);
     const { video } = await client.request(`/api/videos/${encodeURIComponent(args.id)}`);
     out(stdout, await client.request(`/api/v1/videos/${encodeURIComponent(args.id)}`, { method: "PATCH", body: videoDetails.parse({ ...video, visibility: flags.visibility, recipients: sharingEmails(flags.share) }) }));
-  }))).add(defineCommand("delete", { description: "Remove a video and its hosted files" }, (command) => command.args({ name: "id", type: "string", required: true }).flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }, { name: "yes", type: "boolean", required: true }).action(async ({ args, flags, stdout, signal }) => {
+  }))).add(defineCommand("subtitles", { description: "Add or replace an MP4's subtitles in one language, or remove a language" }, (command) => command.args({ name: "id", type: "string", required: true }).flags(
+    { name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } },
+    { name: "file", type: "string", description: ".srt or .vtt subtitle file" },
+    { name: "language", type: "string", description: "Language code such as en or tr; defaults to a WebVTT Language header or the export receipt" },
+    { name: "remove", type: "string", description: "Language code of the subtitles to remove" },
+    { name: "yes", type: "boolean", required: true }
+  ).action(async ({ args, flags, stdout, signal }) => out(stdout, await changeVideoSubtitles(new Client(flags.url, signal), args.id, flags))))).add(defineCommand("delete", { description: "Remove a video and its hosted files" }, (command) => command.args({ name: "id", type: "string", required: true }).flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }, { name: "yes", type: "boolean", required: true }).action(async ({ args, flags, stdout, signal }) => {
     if (!flags.yes) throw new Error("Pass --yes to delete the video.");
     out(stdout, await new Client(flags.url, signal).request(`/api/v1/videos/${encodeURIComponent(args.id)}`, { method: "DELETE" }));
   })))).command("auth", (auth) => auth.add(defineCommand("login", { description: "Approve a browser sign-in and save a seven-day CLI session" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" }, description: "Server origin" }).flags({ name: "browser", type: "boolean", default: true, description: "Open the browser; --no-browser prints the URL only" }).action(async ({ flags, stdout, stderr, signal }) => {
@@ -27519,7 +28495,7 @@ Confirm code: ${device.user_code}`);
     const expiresAt = Date.now() + device.expires_in * 1e3;
     let interval = device.interval * 1e3;
     while (Date.now() < expiresAt) {
-      await delay2(interval, void 0, { signal });
+      await delay3(interval, void 0, { signal });
       try {
         const session = await client.request("/api/auth/device/token", { method: "POST", authenticated: false, body: { client_id: CLI_CLIENT_ID, device_code: device.device_code, grant_type: "urn:ietf:params:oauth:grant-type:device_code" } });
         const credentials = await readCredentials();
@@ -27596,7 +28572,7 @@ Confirm code: ${device.user_code}`);
     ...assetAuthorizationFlags
   ).action(async ({ args, flags, stdout, signal }) => out(stdout, await submitAsset(new Client(flags.url, signal), args.id, assetFromFlags(flags), flags))))).add(defineCommand("submit", { description: "Submit a validated JSON asset file; --yes authorizes credits" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }).args(id).flags({ name: "file", type: "string", required: true, description: "JSON asset request" }, { name: "model", type: "string", choices: assetModelIds, description: "Override the model in the file" }, ...assetAuthorizationFlags).action(async ({ args, flags, stdout, signal }) => out(stdout, await submitAsset(new Client(flags.url, signal), args.id, await assetFromFile(flags.file, flags.model), flags))))).add(defineCommand("download", { description: "Download a saved asset by id; refuses to overwrite" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" } }).args(id, { name: "asset", type: "string", required: true, description: "Asset id from assets list" }).flags({ name: "output", type: "string", required: true }).action(async ({ args, flags, stdout, signal }) => out(stdout, await downloadAsset(new Client(flags.url, signal), args.id, args.asset, flags.output)))))).command("jobs", (jobs) => jobs.add(defineCommand("list", { description: "List the latest generation jobs" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" }, description: "Server origin" }).args(id).action(async ({ args, flags, stdout, signal }) => out(stdout, await new Client(flags.url, signal).request(`${projectPath(args.id)}/jobs`))))).add(defineCommand("submit", { description: "Submit a typed JSON job: character, animate, custom or redraw; spends credits" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" }, description: "Server origin" }).args(id).flags(...modelFlags).flags({ name: "file", type: "string", required: true, description: "JSON job file" }, { name: "yes", type: "boolean", required: true, description: "Authorize spending credits" }).action(async ({ args, flags, stdout, signal }) => {
     if (!flags.yes) throw new Error("Pass --yes to authorize spending credits.");
-    const body = spriteJobBody.parse({ ...JSON.parse(await readFile8(flags.file, "utf8")), ...selectedModels(flags) });
+    const body = spriteJobBody.parse({ ...JSON.parse(await readFile12(flags.file, "utf8")), ...selectedModels(flags) });
     out(stdout, await new Client(flags.url, signal).request(`${projectPath(args.id)}/jobs`, { method: "POST", body }));
   }))).add(defineCommand("wait", { description: "Wait for a specific job; fail if generation fails or times out" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" }, description: "Server origin" }).args(id, { name: "job", type: "string", required: true }).flags({ name: "timeout", type: "number", default: 600, description: "Maximum seconds to wait" }).action(async ({ args, flags, stdout, signal }) => {
     if (!Number.isFinite(flags.timeout) || flags.timeout <= 0) throw new Error("Timeout must be positive.");
@@ -27609,7 +28585,7 @@ Confirm code: ${device.user_code}`);
         out(stdout, { job });
         return;
       }
-      await delay2(3e3, void 0, { signal });
+      await delay3(3e3, void 0, { signal });
     }
     throw new Error("Timed out waiting for the job. It may still be running.");
   })))).add(defineCommand("models", { description: "Set default image and/or video models for future project jobs" }, (command) => command.flags({ name: "url", type: "string", default: "https://animaguru.com", env: { name: "ANIMAGURU_URL" }, description: "Server origin" }).args(id).flags({ ...modelFlags[0], aliases: ["model"] }, modelFlags[1]).action(async ({ args, flags, stdout, signal }) => {
@@ -27625,7 +28601,7 @@ Confirm code: ${device.user_code}`);
     const extension = flags.file.split(".").at(-1)?.toLowerCase();
     const type = extension === "png" ? "image/png" : extension === "jpg" || extension === "jpeg" ? "image/jpeg" : extension === "webp" ? "image/webp" : void 0;
     if (!type) throw new Error("Use a PNG, JPEG or WebP image.");
-    const bytes = await readFile8(flags.file);
+    const bytes = await readFile12(flags.file);
     if (bytes.length > 10 * 1024 * 1024) throw new Error("Image must be at most 10 MB.");
     const form = new FormData();
     form.set("image", new Blob([bytes], { type }), `reference.${extension}`);
@@ -27643,8 +28619,8 @@ Confirm code: ${device.user_code}`);
       const response = await client.request(`/api/v1/blobs/${encodeURIComponent(manifest.ownerId)}/${file2.sha}`, { raw: true });
       entries[path2] = new Uint8Array(await response.arrayBuffer());
     }
-    const path = resolve9(flags.output);
-    await writeFile8(path, zipSync(entries, { level: 0 }), { flag: "wx" });
+    const path = resolve11(flags.output);
+    await writeFile9(path, zipSync(entries, { level: 0 }), { flag: "wx" });
     out(stdout, { path, files: manifest.files.length });
   })))).extend(version(package_default.version, { format: "plain" })).extend(help()).extend(completion());
 }