@docyrus/animaguru 0.8.1 → 0.9.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.9.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 [open5, close] = styleMethodCodes[name];
   return [name, {
-    open: `\x1B[${open3}m`,
+    open: `\x1B[${open5}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: open5, close } = style2;
+  if (result.includes(close)) result = result.replaceAll(close, close + open5);
+  return open5 + 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 open5 = "";
     let close = "";
     for (const step of steps) {
       const pair = stepPair(step, pairDepth);
-      open3 += pair.open;
+      open5 += pair.open;
       close = pair.close + close;
     }
     Object.defineProperty(styleFn, "open", {
-      value: open3,
+      value: open5,
       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 readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import { resolve as resolve10 } 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, resolve11) {
   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, resolve11);
       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, resolve11) : 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 ?? (resolve11 ? 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: createHash4 } = await import("node:crypto");
+  await writeFile6(join5(directory, "templates/animation/starter-film.sha256"), createHash4("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"));
@@ -27209,6 +27206,11 @@ import { createHash } from "node:crypto";
 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"]),
@@ -27360,7 +27364,7 @@ async function submitVideo(client, options) {
   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;
+  let completed2 = false;
   try {
     for (let offset = 0, part = 1; offset < info.size; offset += draft.partBytes, part++) {
       options.signal?.throwIfAborted();
@@ -27382,10 +27386,10 @@ async function submitVideo(client, options) {
     if (poster) await client.request(`/api/v1/videos/${draft.id}/poster`, { method: "PUT", body: new Blob([new Uint8Array(poster)]) });
     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();
@@ -27453,6 +27457,797 @@ async function downloadAsset(client, project, assetId, output2) {
   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 createHash2, timingSafeEqual } from "node:crypto";
+import { readFile as readFile9, stat as stat2 } from "node:fs/promises";
+
+// cli/src/youtube-store.ts
+import { chmod as chmod3, lstat, mkdir as mkdir7, open as open3, readFile as readFile8, 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 readFile8(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 open3(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 seconds = options.timeout ?? 300;
+  if (!Number.isFinite(seconds) || seconds < 1 || seconds > 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 stat2(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 readFile9(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((resolve11, reject) => {
+      receive = resolve11;
+      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((resolve11, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", resolve11);
+    });
+    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.")), seconds * 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: createHash2("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((resolve11) => server.close(() => resolve11()));
+    }
+  });
+}
+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 createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { open as open4, readFile as readFile10, stat as stat3 } from "node:fs/promises";
+import { basename as basename4, join as join9, resolve as resolve9 } 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 open4(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 = createHash3("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;
+  }
+}
+async function exportReceipt(file2) {
+  try {
+    const receipt = JSON.parse(await readFile10(file2.replace(/\.mp4$/i, ".json"), "utf8"));
+    if (receipt.file !== basename4(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 readCaptionFile(file2) {
+  let info;
+  try {
+    info = await stat3(file2);
+  } catch {
+    throw new Error(`Cannot read the subtitle file ${file2}.`);
+  }
+  if (!info.isFile() || !/\.(?:srt|vtt)$/i.test(file2) || info.size < 1 || info.size > 5 * 1024 * 1024) throw new Error("Use a .srt or .vtt subtitle file up to 5 MiB, such as the one npm run export:mp4 writes beside the MP4.");
+  const content = await readFile10(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: createHash3("sha256").update(content).digest("hex") };
+}
+async function planCaptions(root, mp4, options, fallbackLanguage) {
+  const choice = options.captions ?? "auto";
+  if (choice === "none") return null;
+  let file2 = choice === "auto" ? void 0 : resolve9(root, choice);
+  if (!file2) {
+    for (const extension of [".srt", ".vtt"]) {
+      const candidate = mp4.replace(/\.mp4$/i, extension);
+      if (await stat3(candidate).then((info) => info.isFile(), () => false)) {
+        file2 = candidate;
+        break;
+      }
+    }
+    if (!file2) return null;
+  }
+  const { content, sha256 } = await readCaptionFile(file2);
+  const header = /^\uFEFF?WEBVTT[^\n]*\n(?:[^\n]+\n)*?Language:[ \t]*([^\s]+)/.exec(content.toString("utf8"))?.[1];
+  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 stat3(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 readFile10(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: createHash3("sha256").update(content).digest("hex") };
+}
+async function planThumbnail(root, mp4, choice = "auto") {
+  if (choice === "none") return null;
+  let file2 = choice === "auto" ? void 0 : resolve9(root, choice);
+  if (!file2) {
+    for (const extension of [".jpg", ".jpeg", ".png"]) {
+      const candidate = mp4.replace(/\.mp4$/i, extension);
+      if (await stat3(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 = resolve9(options.directory ?? ".");
+  const file2 = resolve9(root, options.file);
+  const context = await localProject(root, options.animation);
+  let config2 = {};
+  try {
+    config2 = JSON.parse(await readFile10(join9(context.projectRoot, "film.config.json"), "utf8"));
+  } catch {
+  }
+  const receipt = await exportReceipt(file2);
+  const parsed = youtubeMetadata.safeParse({ title: options.title ?? receipt.title ?? config2.title ?? basename4(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 +28273,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((resolve11) => {
     const child = spawn3(command, args, { stdio: "ignore", detached: true });
-    child.once("error", () => resolve10());
+    child.once("error", () => resolve11());
     child.once("spawn", () => {
       child.unref();
-      resolve10();
+      resolve11();
     });
   });
 }
 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(
@@ -27519,7 +28335,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 +28412,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 readFile11(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 +28425,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 +28441,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 readFile11(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 +28459,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 = resolve10(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());
 }