@koda-sl/baker-cli 0.203.0 → 0.208.1

package/dist/cli.js

@@ -18,18 +18,23 @@ import {
   SEEDANCE_PROFILE,
   VIDEO_GENERATE_MODELS,
   ValidationError,
+  YtDlpError,
+  canonicalUrl,
   clipParamRecipe,
   clipProfileFor,
   collectAssetRefLikes,
   createEngineFromEnv,
   defaultRegistry,
   describeFailureReason,
+  durationSeconds,
   elementMentionKeywords,
   estimateVideoCredits,
   fetchExternalBytes,
   generateCatalog,
   imageProfileFor,
+  isAudioOnly,
   isPersistedAssetRef,
+  isVimeoAuthFailure,
   looksLikeHttpUrl,
   maxInputReferences,
   maxInputSlot,
@@ -38,9 +43,11 @@ import {
   nearestSupportedImageSize,
   parseRefExpr,
   platformFormats,
+  probeYtDlp,
   promptMaxLength,
   requireCredentialsFromEnv,
   resolveConcurrency,
+  runYtDlp,
   sha256Hex,
   spineInputFlags,
   spineInputOps,
@@ -49,8 +56,9 @@ import {
   supportsReferenceToVideo,
   toModelSafeImage,
   ulid,
-  validateCanvasDeep
-} from "./chunk-5MPIOGRO.js";
+  validateCanvasDeep,
+  ytDlpBlockSignal
+} from "./chunk-E2WYWHJJ.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -59,7 +67,7 @@ import {
   resolveAccountIdArg,
   resolveEffectiveStatus,
   todayIso
-} from "./chunk-SVHFT7AN.js";
+} from "./chunk-3WODSPNZ.js";
 import {
   buildQueryCacheKey,
   cacheGet,
@@ -75,20 +83,21 @@ import {
   writeAdsJson,
   writeAdsOutput,
   writeJsonEnvelope
-} from "./chunk-KHHD26LZ.js";
+} from "./chunk-FUSTYLP5.js";
 import {
   ApiError,
   apiGet,
   apiPost,
   validateConvexId
-} from "./chunk-2R2DEPG7.js";
+} from "./chunk-CRXSLYEX.js";
 import {
   installStreamTaps,
   logInvocation
-} from "./chunk-UZYVSPCA.js";
+} from "./chunk-3E33AGNR.js";
 import {
   captureBudgetMs,
   captureProxyCredentials,
+  captureVimeoCookie,
   getEnv,
   isProxyFailure,
   plannedRoutes,
@@ -96,10 +105,10 @@ import {
   requireChatId,
   resolveChatId,
   shouldEscalate
-} from "./chunk-6NZG2TCM.js";
+} from "./chunk-IRNM3T6B.js";
 
 // src/cli.ts
-import { defineCommand as defineCommand216, runMain } from "citty";
+import { defineCommand as defineCommand217, runMain } from "citty";
 
 // src/commands/actions/index.ts
 import { defineCommand as defineCommand18 } from "citty";
@@ -5761,6 +5770,30 @@ var testimonialsOutscraperWebhookResponseSchema = z18.object({
 // ../api/src/videos.ts
 import { z as z19 } from "zod";
 var videoStatusSchema = z19.enum(["uploading", "uploaded", "processing", "ready", "error"]);
+var videoSourceSchema = z19.enum([
+  "uploaded",
+  "url",
+  "bilibili",
+  "bluesky",
+  "dailymotion",
+  "facebook",
+  "instagram",
+  "loom",
+  "newgrounds",
+  "ok",
+  "pinterest",
+  "reddit",
+  "rutube",
+  "snapchat",
+  "streamable",
+  "tiktok",
+  "tumblr",
+  "twitch",
+  "twitter",
+  "vimeo",
+  "vk",
+  "youtube"
+]);
 var videoTranscriptSegmentSchema = z19.object({
   text: z19.string(),
   startSecond: z19.number(),
@@ -5861,6 +5894,25 @@ var videosUploadRequestSchema = z19.object({
   descriptionContext: z19.string().optional()
 });
 var videosUploadResponseSchema = z19.object({ uploadUrl: z19.string(), videoId: z19.string() });
+var videosIngestRequestSchema = z19.object({
+  // Must be a direct media file Mux can pull (mp4/mov/webm/…). A page URL —
+  // a YouTube watch link, a TikTok post — is not one: the CLI resolves those to
+  // a media file before calling this route.
+  url: z19.string().url(),
+  source: videoSourceSchema,
+  externalId: z19.string().optional(),
+  externalUrl: z19.string().optional(),
+  // What the person adding the clip knew that the frames cannot show — which
+  // campaign it belongs to, whether the person on camera is a real customer.
+  // The upload route has carried this since it existed; ingest silently dropped
+  // it, so a link-added clip was analysed with strictly less to go on than the
+  // same file uploaded by hand.
+  descriptionContext: z19.string().optional()
+});
+var videosIngestResponseSchema = z19.object({
+  videoId: z19.string(),
+  deduped: z19.boolean()
+});
 var videosDeleteRequestSchema = z19.object({ id: z19.string().min(1, "Missing video ID") });
 var videosDeleteResponseSchema = z19.object({ ok: z19.literal(true) });
 
@@ -8821,11 +8873,11 @@ function rawTextEntries(value) {
   const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
   return values.filter((v) => typeof v === "string").flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
 }
-function rawFileEntries(path37) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function rawFileEntries(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return [];
   }
-  return readFileSync2(path37, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return readFileSync2(path38, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function keywordEntries(args) {
   const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
@@ -8848,19 +8900,19 @@ function keywordEntries(args) {
   }
   return entries;
 }
-function loadJsonFileArg(path37) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function loadJsonFileArg(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync2(path37, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path38, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation(`${path37} must contain a JSON object`);
+      failWriteValidation(`${path38} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation(`${path37} is not valid JSON: ${err.message}`);
+      failWriteValidation(`${path38} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -8990,10 +9042,10 @@ async function stageUpdate(kind, customerId, target, payload, hints) {
 async function stageTarget(kind, customerId, target, hints) {
   await stageGoogleOp({ kind, customerId, target }, hints);
 }
-async function draftAction(path37, body, chat) {
+async function draftAction(path38, body, chat) {
   try {
     const chatId = resolveChatId(chat);
-    const response = await apiPost(path37, { chatId, ...body });
+    const response = await apiPost(path38, { chatId, ...body });
     writeJsonEnvelope(response);
   } catch (err) {
     handleGoogleError(err);
@@ -11851,19 +11903,19 @@ function failWriteValidation2(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg2(path37) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function loadJsonFileArg2(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync4(path37, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path38, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation2(`${path37} must contain a JSON object`);
+      failWriteValidation2(`${path38} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation2(`${path37} is not valid JSON: ${err.message}`);
+      failWriteValidation2(`${path38} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -11948,15 +12000,15 @@ function parseLocaleFlag(value) {
   }
   return { language: match[1], country: match[2].toUpperCase() };
 }
-function loadTargetingFileArg(path37) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function loadTargetingFileArg(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return void 0;
   }
-  const parsed = loadJsonFileArg2(path37);
+  const parsed = loadJsonFileArg2(path38);
   const criteria = parsed.targetingCriteria ?? parsed;
   if (!criteria.include) {
     failWriteValidation2(
-      `${path37} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+      `${path38} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
     );
   }
   return criteria;
@@ -11991,14 +12043,14 @@ function parseCsvLine(line) {
   cells.push(current);
   return cells.map((cell) => cell.trim());
 }
-function parseListFileArg(path37, maxRows) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function parseListFileArg(path38, maxRows) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return void 0;
   }
-  const raw = readFileSync4(path37, "utf8");
+  const raw = readFileSync4(path38, "utf8");
   const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
   if (lines.length < 2) {
-    failWriteValidation2(`${path37} needs a header row and at least one data row`);
+    failWriteValidation2(`${path38} needs a header row and at least one data row`);
   }
   const columns = parseCsvLine(lines[0]).map((column) => column.trim());
   const rows = [];
@@ -12017,7 +12069,7 @@ function parseListFileArg(path37, maxRows) {
     }
   }
   if (rows.length > maxRows) {
-    failWriteValidation2(`${path37} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+    failWriteValidation2(`${path38} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
   }
   return { columns, rows };
 }
@@ -12113,11 +12165,11 @@ function readPositionals(args) {
 function splitIdList(raw) {
   return raw.split(",").map((id) => id.trim()).filter(Boolean);
 }
-function idsFileEntries(path37) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function idsFileEntries(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return [];
   }
-  return readFileSync4(path37, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+  return readFileSync4(path38, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
 }
 function requireTargets(args, entity) {
   const positionals = readPositionals(args);
@@ -14740,9 +14792,9 @@ function compactRow(row) {
     ...destination.postUrn ? { postUrn: destination.postUrn } : {}
   };
 }
-function readPath(row, path37) {
+function readPath(row, path38) {
   let current = row;
-  for (const segment of path37.split(".")) {
+  for (const segment of path38.split(".")) {
     const record = asRecord2(current);
     if (!record) return void 0;
     current = record[segment];
@@ -14752,10 +14804,10 @@ function readPath(row, path37) {
 function projectFields(rows, paths) {
   return rows.map((row) => {
     const projected = {};
-    for (const path37 of paths) {
-      const value = readPath(row, path37);
+    for (const path38 of paths) {
+      const value = readPath(row, path38);
       if (value !== void 0) {
-        projected[path37] = value;
+        projected[path38] = value;
       }
     }
     return projected;
@@ -16049,11 +16101,11 @@ var updateStatusSchema = z21.enum(UPDATE_STATUSES);
 function currencyMinimums2(currencyCode) {
   return CURRENCY_MINIMUMS2[currencyCode] ?? DEFAULT_CURRENCY_MINIMUM2;
 }
-function validateDailyBudgetFloor(money, ctx, path37) {
+function validateDailyBudgetFloor(money, ctx, path38) {
   if (money?.currencyCode) {
     const min = currencyMinimums2(money.currencyCode).dailyBudgetMin;
     if (Number(money.amount) < min) {
-      ctx.addIssue({ code: "custom", path: path37, message: `below the ${min} ${money.currencyCode} daily minimum` });
+      ctx.addIssue({ code: "custom", path: path38, message: `below the ${min} ${money.currencyCode} daily minimum` });
     }
   }
 }
@@ -16715,19 +16767,19 @@ function failWriteValidation3(message) {
   writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
   process.exit(1);
 }
-function loadJsonFileArg3(path37) {
-  if (typeof path37 !== "string" || path37.length === 0) {
+function loadJsonFileArg3(path38) {
+  if (typeof path38 !== "string" || path38.length === 0) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path37, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path38, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      failWriteValidation3(`${path37} must contain a JSON object`);
+      failWriteValidation3(`${path38} must contain a JSON object`);
     }
     return parsed;
   } catch (err) {
     if (err instanceof SyntaxError) {
-      failWriteValidation3(`${path37} is not valid JSON: ${err.message}`);
+      failWriteValidation3(`${path38} is not valid JSON: ${err.message}`);
     }
     throw err;
   }
@@ -17270,10 +17322,10 @@ function duplicateCommand2(entity, label) {
       replace: { type: "boolean", description: "Pause the original once the copy publishes" }
     },
     run: async ({ args }) => {
-      const { apiPost: apiPost2 } = await import("./client-MP7BKFKM.js");
-      const { requireChatId: requireChatId2 } = await import("./env-FF7ZB5W5.js");
-      const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-YGPWST77.js");
-      const { handleMetaError: handleMetaError2 } = await import("./shared-CRWB5B7P.js");
+      const { apiPost: apiPost2 } = await import("./client-CF6ZORCO.js");
+      const { requireChatId: requireChatId2 } = await import("./env-7SCX7HAH.js");
+      const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-4YIOSWOG.js");
+      const { handleMetaError: handleMetaError2 } = await import("./shared-EBF5DEDJ.js");
       try {
         const accountId = bareAccountId2(args);
         const chatId = requireChatId2();
@@ -27898,12 +27950,12 @@ function listFlowSlugs() {
   return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
 }
 function readFlowTree(slug) {
-  const path37 = join3(flowsDir(), slug, "_data.json");
-  if (!existsSync5(path37)) {
+  const path38 = join3(flowsDir(), slug, "_data.json");
+  if (!existsSync5(path38)) {
     failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
   }
   try {
-    return JSON.parse(readFileSync9(path37, "utf-8"));
+    return JSON.parse(readFileSync9(path38, "utf-8"));
   } catch (error) {
     failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -28316,10 +28368,10 @@ async function stageOps(ops) {
     handleError(err);
   }
 }
-async function draftAction2(path37, body, chat) {
+async function draftAction2(path38, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path37, { chatId, ...body });
+    const data = await apiPost(path38, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -30340,9 +30392,9 @@ async function readImageBuffer(pathOrUrl) {
   }
   return readFile19(pathOrUrl);
 }
-async function isDirectory(path37) {
+async function isDirectory(path38) {
   try {
-    const s = await stat4(path37);
+    const s = await stat4(path38);
     return s.isDirectory();
   } catch {
     return false;
@@ -30626,13 +30678,13 @@ function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDi
 }
 function disambiguate(paths) {
   const taken = /* @__PURE__ */ new Set();
-  return paths.map((path37) => {
-    if (!taken.has(path37)) {
-      taken.add(path37);
-      return path37;
+  return paths.map((path38) => {
+    if (!taken.has(path38)) {
+      taken.add(path38);
+      return path38;
     }
-    const ext = extname3(path37);
-    const stem = path37.slice(0, path37.length - ext.length);
+    const ext = extname3(path38);
+    const stem = path38.slice(0, path38.length - ext.length);
     let n = 2;
     while (taken.has(`${stem}-${n}${ext}`)) n += 1;
     const unique = `${stem}-${n}${ext}`;
@@ -30759,10 +30811,10 @@ async function runDownloads(plan) {
   const paths = disambiguate(fetched.map((item) => item.path));
   const downloaded = [];
   for (const [index, item] of fetched.entries()) {
-    const path37 = paths[index] ?? item.path;
+    const path38 = paths[index] ?? item.path;
     try {
-      await atomicWrite(path37, item.buffer);
-      downloaded.push({ input: item.input, output: path37, bytes: item.buffer.length, contentType: item.contentType });
+      await atomicWrite(path38, item.buffer);
+      downloaded.push({ input: item.input, output: path38, bytes: item.buffer.length, contentType: item.contentType });
     } catch (err) {
       failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
     }
@@ -32513,14 +32565,14 @@ async function processInternal(inputBuffer, isSVG, options) {
     processedData = result.data;
     info = result.info;
   }
-  let pipeline = sharp2(processedData, {
+  let pipeline2 = sharp2(processedData, {
     raw: { channels: 4, width: info.width, height: info.height }
   }).png();
   if (options.shrinkToContent) {
     stages.push("trim");
-    pipeline = pipeline.trim();
+    pipeline2 = pipeline2.trim();
   }
-  const outputBuffer = await pipeline.toBuffer();
+  const outputBuffer = await pipeline2.toBuffer();
   return { buffer: outputBuffer, stages };
 }
 function applyResize(buffer, resize) {
@@ -40493,7 +40545,7 @@ function parseImageRefs(spec) {
 }
 var defaultDeps = {
   ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
-  upload: (path37) => uploadLocalImage({ file: path37, contentType: detectImageContentType(path37), source: "uploaded" })
+  upload: (path38) => uploadLocalImage({ file: path38, contentType: detectImageContentType(path38), source: "uploaded" })
 };
 async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   const refs = parseImageRefs(spec);
@@ -40513,10 +40565,10 @@ async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
   }
   return { imageIds, added };
 }
-function uploadFailure(path37) {
+function uploadFailure(path38) {
   return (error) => {
     if (error instanceof ApiError) throw error;
-    throw new ApiError("VALIDATION_ERROR", `Could not read "${path37}" as an image.`);
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path38}" as an image.`);
   };
 }
 
@@ -41566,10 +41618,10 @@ async function stageOp4(op) {
     handleError4(err);
   }
 }
-async function draftAction3(path37, body, chat) {
+async function draftAction3(path38, body, chat) {
   const chatId = resolveChatId(chat);
   try {
-    const data = await apiPost(path37, { chatId, ...body });
+    const data = await apiPost(path38, { chatId, ...body });
     writeJsonEnvelope({ ok: true, data });
     return data;
   } catch (err) {
@@ -42542,7 +42594,7 @@ Full guide: __tooling__/docs/tools/baker/testimonials.md`
 });
 
 // src/commands/videos/index.ts
-import { defineCommand as defineCommand202 } from "citty";
+import { defineCommand as defineCommand203 } from "citty";
 
 // src/commands/videos/delete.ts
 import { defineCommand as defineCommand197 } from "citty";
@@ -42673,8 +42725,420 @@ var groupCommand2 = defineCommand199({
   }
 });
 
-// src/commands/videos/search.ts
+// src/commands/videos/ingest.ts
+import { mkdtemp as mkdtemp2, rm as rm7, stat as stat7 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import path37 from "path";
 import { defineCommand as defineCommand200 } from "citty";
+
+// src/lib/streamUpload.ts
+import { createHash as createHash2 } from "crypto";
+import { createReadStream } from "fs";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+async function hashFile(filePath) {
+  const hash = createHash2("sha256");
+  await pipeline(createReadStream(filePath), hash);
+  return hash.digest("hex");
+}
+async function putFileStreamed(args) {
+  const body = Readable.toWeb(createReadStream(args.filePath));
+  return await fetch(args.putUrl, {
+    method: "PUT",
+    body,
+    headers: {
+      "Content-Type": args.contentType,
+      "Content-Length": String(args.sizeBytes)
+    },
+    duplex: "half"
+  });
+}
+
+// src/commands/videos/videoPlatforms.ts
+var PLATFORM_DOMAINS = {
+  youtube: ["youtube.com", "youtu.be"],
+  instagram: ["instagram.com", "ddinstagram.com"],
+  tiktok: ["tiktok.com"],
+  twitter: ["twitter.com", "x.com", "vxtwitter.com", "fixvx.com"],
+  facebook: ["facebook.com", "fb.watch", "fb.com"],
+  reddit: ["reddit.com", "redd.it"],
+  vimeo: ["vimeo.com"],
+  dailymotion: ["dailymotion.com", "dai.ly"],
+  twitch: ["twitch.tv"],
+  bluesky: ["bsky.app"],
+  bilibili: ["bilibili.com", "bilibili.tv", "b23.tv"],
+  vk: ["vk.com", "vk.ru", "vkvideo.ru"],
+  ok: ["ok.ru"],
+  pinterest: ["pinterest.com", "pin.it"],
+  tumblr: ["tumblr.com"],
+  snapchat: ["snapchat.com"],
+  loom: ["loom.com"],
+  streamable: ["streamable.com"],
+  newgrounds: ["newgrounds.com"],
+  rutube: ["rutube.ru"]
+};
+var VIDEO_PLATFORMS = Object.keys(PLATFORM_DOMAINS);
+function platformFromUrl(rawUrl) {
+  let host;
+  try {
+    host = new URL(rawUrl).hostname.toLowerCase();
+  } catch {
+    return "url";
+  }
+  for (const [platform, domains] of Object.entries(PLATFORM_DOMAINS)) {
+    if (domains.some((domain) => host === domain || host.endsWith(`.${domain}`))) {
+      return platform;
+    }
+  }
+  return "url";
+}
+
+// src/commands/videos/ingestUrl.ts
+var MAX_VIDEO_INGEST_BYTES = 16 * 1024 * 1024 * 1024;
+var MAX_VIDEO_INGEST_SECONDS = 3 * 60 * 60;
+function refuseByDuration(seconds, maxSeconds) {
+  if (seconds === void 0 || seconds <= maxSeconds) return null;
+  return `That video is ${(seconds / 3600).toFixed(1)} hours long \u2014 the limit is ${Math.round(maxSeconds / 3600)} hours.`;
+}
+var DOWNLOAD_TIMEOUT_FLOOR_MS = 10 * 60 * 1e3;
+var DOWNLOAD_TIMEOUT_CEILING_MS = 15 * 60 * 1e3;
+function downloadTimeoutMs(seconds) {
+  if (seconds === void 0) return DOWNLOAD_TIMEOUT_FLOOR_MS;
+  const scaled = seconds * 2 * 1e3;
+  return Math.min(Math.max(scaled, DOWNLOAD_TIMEOUT_FLOOR_MS), DOWNLOAD_TIMEOUT_CEILING_MS);
+}
+var INGEST_MAX_HEIGHT = 1080;
+var DIRECT_MEDIA_EXTENSIONS = [".mp4", ".mov", ".webm", ".m4v", ".mkv", ".avi"];
+function isDirectMediaUrl(rawUrl) {
+  const pathname = safePathname(rawUrl);
+  return DIRECT_MEDIA_EXTENSIONS.some((ext) => pathname.endsWith(ext));
+}
+function resolveIngestSource(explicit, rawUrl) {
+  if (explicit) return explicit;
+  return platformFromUrl(rawUrl);
+}
+var TOOLING_OR_BLOCK_SIGNATURES = [
+  "requested format is not available",
+  "only images are available",
+  "nsig",
+  "sign in to confirm",
+  // bot check — distinct from "Private video. Sign in if…"
+  "unable to download api page",
+  "http error 403",
+  // yt-dlp's own "the site changed under me" signature. It prints a GitHub issue
+  // link whenever a page parsed nothing like the shape the extractor expects —
+  // which is precisely a downloader that has aged out, not a bad link. Observed
+  // live on TikTok, which probed fine and then broke ninety minutes later from
+  // the same machine, identically through direct, datacenter and residential
+  // exits. Without this it fell through to "check the link is public", sending
+  // the reader to inspect a video that was never the problem.
+  "please report this issue"
+];
+function isToolingOrBlockFailure(detail) {
+  const haystack = detail.toLowerCase();
+  return TOOLING_OR_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+var REGION_BLOCK_SIGNATURES = [
+  "in your country",
+  "geo-restricted",
+  "geo restricted",
+  "not available from your location",
+  "blocked in your country"
+];
+function isDrmProtected(detail) {
+  return detail.toLowerCase().includes("drm protected");
+}
+function isRegionBlocked(detail) {
+  const haystack = detail.toLowerCase();
+  return REGION_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+function worthDownloadingInstead(errorCode) {
+  return errorCode === "VALIDATION_ERROR";
+}
+function directDedupeKey(source, rawUrl) {
+  return `${source}:${rawUrl}`;
+}
+function safePathname(rawUrl) {
+  try {
+    return new URL(rawUrl).pathname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+
+// src/commands/videos/ingest.ts
+registerSchema({
+  command: "videos.ingest",
+  description: "Add a video to the library from a URL \u2014 a direct file, or a YouTube/TikTok/Vimeo page.",
+  args: {
+    url: { type: "string", description: "Video URL (direct file or a watch/post page)", required: true },
+    source: { type: "string", description: "Provenance: url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id (deduped on)", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", required: false },
+    download: {
+      type: "boolean",
+      description: "Force the download path instead of letting Baker fetch the URL directly",
+      required: false,
+      default: false
+    },
+    country: {
+      type: "string",
+      description: "Two-letter country to fetch from (e.g. US, DE, JP) \u2014 use when a video is blocked in your region",
+      required: false
+    },
+    context: {
+      type: "string",
+      description: "What you know that the video cannot show \u2014 the campaign, whether the person on camera is a real customer, what it is for. Highest-leverage flag here: it is what makes the clip findable later.",
+      required: false
+    },
+    "dry-run": { type: "boolean", description: "Preview the operation without executing", required: false }
+  }
+});
+var ingestCommand2 = defineCommand200({
+  meta: {
+    name: "ingest",
+    description: "Add a video to the library from a URL. A direct file URL is handed straight to Baker, which fetches it. A page URL (YouTube, TikTok, Vimeo, Instagram) is downloaded here first, then uploaded \u2014 and a direct URL that Baker cannot fetch falls back to that same path automatically.\n\nExample: baker videos ingest https://www.youtube.com/watch?v=abc123"
+  },
+  args: {
+    url: { type: "positional", description: "Video URL", required: false },
+    source: { type: "string", description: "Provenance: url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id", required: false },
+    "external-url": { type: "string", description: "Canonical page URL", required: false },
+    download: { type: "boolean", description: "Force the download path", required: false, default: false },
+    country: { type: "string", description: "Two-letter country to fetch from, e.g. US", required: false },
+    context: {
+      type: "string",
+      description: "Context for the analysis \u2014 campaign, who is on camera, intended use",
+      required: false
+    },
+    "dry-run": { type: "boolean", description: "Preview without executing", required: false, default: false }
+  },
+  run: ({ args }) => runVideoIngest({
+    url: args.url,
+    source: args.source,
+    externalId: args["external-id"],
+    externalUrl: args["external-url"],
+    forceDownload: args.download === true,
+    country: args.country,
+    context: args.context,
+    dryRun: args["dry-run"] === true
+  })
+});
+async function runVideoIngest(opts) {
+  const url = opts.url;
+  if (!url) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "URL is required" } });
+    process.exit(1);
+  }
+  const direct = !opts.forceDownload && isDirectMediaUrl(url);
+  const country = opts.country?.trim() || void 0;
+  const args = {
+    url,
+    source: resolveIngestSource(opts.source, url),
+    externalId: opts.externalId,
+    // Deliberately NOT pre-filled with the pasted URL. Doing so shadowed the
+    // canonical URL the probe resolves (`?? canonicalUrl(...)` below could never
+    // run), so the same video filed under a different `externalUrl` depending on
+    // whether the link was copied from a share sheet, a shorts page or the
+    // address bar. `downloadThenIngest` falls back to `args.url` when the probe
+    // resolves nothing, which is the value this used to hard-code.
+    externalUrl: opts.externalUrl,
+    descriptionContext: opts.context?.trim() || void 0
+  };
+  const validation = videosIngestRequestSchema.safeParse({ ...args, url });
+  if (!validation.success) {
+    const problem = validation.error.issues[0];
+    writeJson({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: problem ? `${problem.path.join(".") || "request"}: ${problem.message}` : "Invalid request"
+      }
+    });
+    process.exit(1);
+  }
+  if (opts.dryRun) {
+    reportDryRun(args, direct, country);
+    return;
+  }
+  try {
+    writeJson({ ok: true, data: await ingestByRoute(args, direct, country) });
+  } catch (err) {
+    reportIngestFailure(err);
+  }
+}
+function reportDryRun(args, direct, country) {
+  writeJson({
+    ok: true,
+    dryRun: true,
+    operation: "videos.ingest",
+    params: {
+      url: args.url,
+      source: args.source,
+      // Known up front on the direct route, because it is derived from the URL
+      // alone. The download route's key comes from the probe, which a dry run
+      // does not perform, so there it stays null rather than becoming a guess.
+      externalId: args.externalId ?? (direct ? directDedupeKey(args.source, args.url) : null),
+      // A page URL's canonical form is only known after the probe, which a dry
+      // run does not perform — so this is null rather than a guess.
+      externalUrl: args.externalUrl ?? null,
+      direct,
+      country: country ?? null,
+      descriptionContext: args.descriptionContext ?? null
+    }
+  });
+}
+async function ingestByRoute(args, direct, country) {
+  if (!direct) {
+    return { ...await downloadThenIngest(args, country), via: "download" };
+  }
+  try {
+    const externalId = args.externalId ?? directDedupeKey(args.source, args.url);
+    return { ...await ingestUrl({ ...args, externalId }), via: "direct" };
+  } catch (err) {
+    if (!(err instanceof ApiError) || !worthDownloadingInstead(err.code)) throw err;
+    return { ...await downloadThenIngest(args, country), via: "download", fallbackFrom: err.message };
+  }
+}
+function reportYtDlpFailure(err) {
+  const detail = `${err.stderrTail} ${err.message}`;
+  if (isProxyFailure(ytDlpBlockSignal(detail))) {
+    fail7(
+      "Couldn't download that video: our connection to the internet was refused.",
+      "This is Baker's egress proxy, not the link \u2014 its credentials look wrong or expired. The link is probably fine. Report it; retrying won't help until the proxy is fixed."
+    );
+  }
+  if (isDrmProtected(detail)) {
+    fail7(
+      "That video is copy-protected, so it can't be added to the library.",
+      "The publisher encrypted this one against downloading. Nothing will change that \u2014 not retrying, not a different region. Ask whoever owns the video for the original file and add it with `baker videos upload <file>`."
+    );
+  }
+  if (isVimeoAuthFailure(detail)) {
+    fail7(
+      "Vimeo wouldn't hand over that video \u2014 Baker isn't signed in to Vimeo.",
+      "Vimeo now refuses anonymous downloads entirely, so this needs a signed-in session and the one Baker holds has either expired or was never set. Nothing is wrong with the link. Report it so the Vimeo cookie can be refreshed; meanwhile download the file and use `baker videos upload <file>`."
+    );
+  }
+  if (isRegionBlocked(detail)) {
+    fail7(
+      `That video isn't available in the region we're fetching from. ${err.stderrTail || err.message}`,
+      "Re-run with `--country <two-letter code>` for a country where the video plays \u2014 e.g. `--country US`. Pick the one the video belongs to (the uploader's country is the usual answer); each attempt costs a paid connection, so choose rather than work through the list."
+    );
+  }
+  fail7(
+    `Couldn't download that video. ${err.stderrTail || err.message}`,
+    isToolingOrBlockFailure(detail) ? "The site wouldn't hand over the video \u2014 usually the downloader being out of date against a site that changed, or the request being blocked. Retrying won't help, and the link is probably fine. Report it so the tool can be updated; meanwhile download the file and use `baker videos upload <file>`." : "Check the link is public and playable. Private or age-restricted videos can't be downloaded \u2014 download the file yourself and use `baker videos upload <file>`."
+  );
+}
+function fail7(message, fix, code = "INGEST_FAILED") {
+  writeJson({ ok: false, error: { code, message, fix } });
+  process.exit(1);
+}
+function reportIngestFailure(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof YtDlpError) reportYtDlpFailure(err);
+  const detail = err instanceof Error ? err.message : String(err);
+  if (detail.includes("timed out after")) {
+    fail7(
+      "That video took too long to download and was stopped part-way.",
+      "Long or slow-serving videos can outrun the download window. Try a shorter clip, or download this one yourself and use `baker videos upload <file>`.",
+      "INTERNAL_ERROR"
+    );
+  }
+  fail7(
+    `Couldn't add that video. ${detail}`,
+    "This is a fault on Baker's side, not a problem with the link. Report it.",
+    "INTERNAL_ERROR"
+  );
+}
+function dedupeKey(args, info) {
+  const id = typeof info.id === "string" ? info.id : void 0;
+  if (!id) return void 0;
+  if (info.extractor === "generic") return `${args.source}:${canonicalUrl(info) ?? args.url}`;
+  return `${args.source}:${id}`;
+}
+function ingestUrl(args) {
+  const body = {
+    url: args.url,
+    source: args.source
+  };
+  if (args.externalId) body.externalId = args.externalId;
+  if (args.externalUrl) body.externalUrl = args.externalUrl;
+  if (args.descriptionContext) body.descriptionContext = args.descriptionContext;
+  return apiPost("/api/videos/ingest", body);
+}
+async function downloadThenIngest(args, country) {
+  const vimeoCookie = captureVimeoCookie();
+  const workDir = await mkdtemp2(path37.join(tmpdir3(), "videos-ingest-"));
+  try {
+    const probe = await probeYtDlp({ url: args.url, country, vimeoCookie, cookieDir: workDir });
+    if (isAudioOnly(probe.info)) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        "That link is audio, not video, so it can't go in the video library. Music and podcast links have no picture to store."
+      );
+    }
+    const tooLong = refuseByDuration(durationSeconds(probe.info), MAX_VIDEO_INGEST_SECONDS);
+    if (tooLong) {
+      throw new ApiError("VALIDATION_ERROR", tooLong);
+    }
+    const externalId = args.externalId ?? dedupeKey(args, probe.info);
+    const { filePath, tier } = await runYtDlp({
+      url: args.url,
+      audioOnly: false,
+      workDir,
+      maxHeight: INGEST_MAX_HEIGHT,
+      country,
+      vimeoCookie,
+      // Budgeted from the probed length, so the duration we accept and the time
+      // we allow to fetch it cannot drift apart.
+      timeoutMs: downloadTimeoutMs(durationSeconds(probe.info))
+    });
+    const stats = await stat7(filePath);
+    if (stats.size > MAX_VIDEO_INGEST_BYTES) {
+      throw new ApiError(
+        "VALIDATION_ERROR",
+        `That video is ${(stats.size / 1024 ** 3).toFixed(1)} GB, over the ${Math.round(MAX_VIDEO_INGEST_BYTES / 1024 ** 3)} GB limit for this route.`
+      );
+    }
+    const publicUrl = await uploadToAssetStore(filePath, stats.size);
+    return {
+      ...await ingestUrl({
+        ...args,
+        url: publicUrl,
+        externalId,
+        externalUrl: args.externalUrl ?? canonicalUrl(probe.info) ?? args.url
+      }),
+      egress: tier,
+      // Named in the result for the same reason `egress` is: a geo-targeted exit
+      // is a deliberate, billable choice and must not be invisible afterwards.
+      ...country ? { country } : {}
+    };
+  } finally {
+    await rm7(workDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function uploadToAssetStore(filePath, sizeBytes) {
+  const sha256 = await hashFile(filePath);
+  const { putUrl, publicUrl } = await apiPost("/api/canvas/assets/presign", {
+    sha256,
+    mime: "video/mp4",
+    purpose: "source"
+  });
+  const putRes = await putFileStreamed({ putUrl, filePath, contentType: "video/mp4", sizeBytes });
+  if (!putRes.ok) {
+    throw new ApiError("INTERNAL_ERROR", `Storing the downloaded video failed: HTTP ${putRes.status}`);
+  }
+  return publicUrl;
+}
+
+// src/commands/videos/search.ts
+import { defineCommand as defineCommand201 } from "citty";
 registerSchema({
   command: "videos.search",
   description: "Search videos by text query. Only returns ready videos.",
@@ -42684,7 +43148,7 @@ registerSchema({
     tags: { type: "string", description: "Comma-separated tags to filter by", required: false }
   }
 });
-var searchCommand4 = defineCommand200({
+var searchCommand4 = defineCommand201({
   meta: {
     name: "search",
     description: "Semantic search videos by text query. Uses hybrid BM25 + vector + reranking. Example: baker videos search 'product demo' --tags tutorial"
@@ -42734,9 +43198,9 @@ var searchCommand4 = defineCommand200({
 var tagsCommand5 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
-import { readFile as readFile24, stat as stat7 } from "fs/promises";
+import { readFile as readFile24, stat as stat8 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
-import { defineCommand as defineCommand201 } from "citty";
+import { defineCommand as defineCommand202 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
   ".mov": "video/quicktime",
@@ -42746,9 +43210,9 @@ var MIME_MAP = {
 };
 registerSchema({
   command: "videos.upload",
-  description: "Upload a video file to Baker (via Mux direct upload)",
+  description: "Upload a video to Baker \u2014 a local file (via Mux direct upload) or a remote http(s) URL.",
   args: {
-    file: { type: "string", description: "Path to the video file", required: true },
+    file: { type: "string", description: "Local video file path, or a remote http(s) URL", required: true },
     "content-type": {
       type: "string",
       description: "MIME type (auto-detected from extension if omitted)",
@@ -42775,33 +43239,50 @@ function detectContentType(filePath) {
   }
   return mime;
 }
-var uploadCommand2 = defineCommand201({
+function isRemoteUrl3(value) {
+  return /^https?:\/\//i.test(value);
+}
+var uploadCommand2 = defineCommand202({
   meta: {
     name: "upload",
-    description: "Upload a video file to Baker via Mux direct upload. Auto-detects content type. Example: baker videos upload ./demo.mp4"
+    description: "Upload a video to Baker \u2014 accepts a local file path OR a remote http(s) URL.\n\nLocal: auto-detects content type and uploads via Mux direct upload.\nRemote: hands off to `videos ingest` (direct fetch, or download-then-upload for a YouTube/TikTok/Vimeo page).\n\nExamples:\n  baker videos upload ./demo.mp4\n  baker videos upload https://www.youtube.com/watch?v=abc123"
   },
   args: {
-    file: { type: "positional", description: "Path to the video file", required: false },
-    "content-type": { type: "string", description: "MIME type (auto-detected if omitted)", required: false },
+    file: { type: "positional", description: "Local video file path or remote http(s) URL", required: false },
+    "content-type": { type: "string", description: "MIME type (local only \u2014 auto-detected)", required: false },
     context: {
       type: "string",
       description: "What this clip is and what it is for \u2014 who is on camera, which campaign, how it was shot. Start here: the analysis reads it, so it is what makes the clip findable later.",
       required: false
     },
+    source: { type: "string", description: "Provenance (URL mode only): url | youtube", required: false },
+    "external-id": { type: "string", description: "Provider asset id (URL mode only)", required: false },
+    "external-url": { type: "string", description: "Canonical page URL (URL mode only)", required: false },
     "dry-run": { type: "boolean", description: "Preview without executing", required: false, default: false }
   },
   run: async ({ args }) => {
     try {
       const filePath = args.file;
       if (!filePath) {
-        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "File path is required" } });
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "File path or URL is required" } });
         process.exit(1);
       }
+      if (isRemoteUrl3(filePath)) {
+        await runVideoIngest({
+          url: filePath,
+          source: args.source,
+          externalId: args["external-id"],
+          externalUrl: args["external-url"],
+          context: args.context,
+          dryRun: args["dry-run"] === true
+        });
+        return;
+      }
       const contentType = args["content-type"] || detectContentType(filePath);
       const originalFilename = basename3(filePath);
       const descriptionContext = args.context;
       if (args["dry-run"]) {
-        const fileStats = await stat7(filePath);
+        const fileStats = await stat8(filePath);
         writeJson({
           ok: true,
           dryRun: true,
@@ -42845,16 +43326,17 @@ var uploadCommand2 = defineCommand201({
 });
 
 // src/commands/videos/index.ts
-var videosCommand = defineCommand202({
+var videosCommand = defineCommand203({
   meta: {
     name: "videos",
-    description: `Find and manage videos in Baker. Subcommands: search, get, upload, delete, tags.
+    description: `Find and manage videos in Baker. Subcommands: search, get, upload, ingest, delete, tags.
 
 Examples:
   baker videos search "product demo" --limit 5
   baker videos search "tutorial" --tags explainer
   baker videos get <video-id>
   baker videos upload ./demo.mp4
+  baker videos ingest https://www.youtube.com/watch?v=abc123
   baker videos delete <video-id> --dry-run
   baker videos tags
 Full guide: __tooling__/docs/tools/baker/videos.md`
@@ -42864,16 +43346,17 @@ Full guide: __tooling__/docs/tools/baker/videos.md`
     group: groupCommand2,
     search: searchCommand4,
     upload: uploadCommand2,
+    ingest: ingestCommand2,
     delete: deleteCommand3,
     tags: tagsCommand5
   }
 });
 
 // src/commands/winning-ads/index.ts
-import { defineCommand as defineCommand215 } from "citty";
+import { defineCommand as defineCommand216 } from "citty";
 
 // src/commands/winning-ads/advertisers.ts
-import { defineCommand as defineCommand203 } from "citty";
+import { defineCommand as defineCommand204 } from "citty";
 
 // src/commands/winning-ads/shared.ts
 function splitList2(value) {
@@ -42926,7 +43409,7 @@ function advertiserNormalizer(record, full) {
     last_synced_at: record.last_synced_at ?? null
   };
 }
-var advertisersCommand2 = defineCommand203({
+var advertisersCommand2 = defineCommand204({
   meta: {
     name: "advertisers",
     description: 'List corpus advertisers by name or domain. Find your own advertiser for --exclude-advertiser, or a competitor for --advertiser-id / winners. Example: baker winning-ads advertisers "Deel" --output md'
@@ -42984,7 +43467,7 @@ var advertisersCommand2 = defineCommand203({
 });
 
 // src/commands/winning-ads/brief.ts
-import { defineCommand as defineCommand204 } from "citty";
+import { defineCommand as defineCommand205 } from "citty";
 registerSchema({
   command: "winning-ads.brief",
   description: "Generate a creative brief grounded in strategically-similar winning ads. Optionally describe the target creative with --dna (JSON) and steer with --notes.",
@@ -43030,7 +43513,7 @@ function parseDna(raw) {
   }
   return parsed;
 }
-var briefCommand = defineCommand204({
+var briefCommand = defineCommand205({
   meta: {
     name: "brief",
     description: `Generate a creative brief from winning references. Example: baker winning-ads brief --dna '{"angle":"cost savings"}' --notes "B2B, LinkedIn video" --k 8`
@@ -43066,7 +43549,7 @@ var briefCommand = defineCommand204({
 });
 
 // src/commands/winning-ads/content.ts
-import { defineCommand as defineCommand205 } from "citty";
+import { defineCommand as defineCommand206 } from "citty";
 registerSchema({
   command: "winning-ads.content",
   description: "Read what's INSIDE one winning ad: the spoken transcript, the on-screen text, and the ad copy. Use this after `search`/`winners`/`feed` return a shortlist \u2014 pass an ad_id to understand a reference before reproducing it. Add --full for speech, pacing, and soundtrack detail. Video ads carry the transcript/on-screen text; static ads carry only the copy.",
@@ -43079,7 +43562,7 @@ registerSchema({
     }
   }
 });
-var contentCommand = defineCommand205({
+var contentCommand = defineCommand206({
   meta: {
     name: "content",
     description: "Read the transcript + on-screen text + copy of one winning ad. Example: baker winning-ads content adg_123 --platform meta --full --output md"
@@ -43128,7 +43611,7 @@ var contentCommand = defineCommand205({
 });
 
 // src/commands/winning-ads/feed.ts
-import { defineCommand as defineCommand206 } from "citty";
+import { defineCommand as defineCommand207 } from "citty";
 function buildFeedParams(input) {
   const params = {};
   const advertiser = splitList2(input.advertiser);
@@ -43180,7 +43663,7 @@ registerSchema({
     format: { type: "string", description: "Comma-separated formats to include (e.g. static,video)", required: false }
   }
 });
-var feedCommand = defineCommand206({
+var feedCommand = defineCommand207({
   meta: {
     name: "feed",
     description: "Winners across every brand you follow (browse, then trim per advertiser). Example: baker winning-ads feed --per-advertiser 5 --output md"
@@ -43265,7 +43748,7 @@ var feedCommand = defineCommand206({
 });
 
 // src/commands/winning-ads/follow.ts
-import { defineCommand as defineCommand207 } from "citty";
+import { defineCommand as defineCommand208 } from "citty";
 var PLATFORMS = ["meta", "linkedin"];
 registerSchema({
   command: "winning-ads.follow",
@@ -43280,7 +43763,7 @@ registerSchema({
     label: { type: "string", description: "Optional display label (defaults to the resolved name)", required: false }
   }
 });
-var followCommand = defineCommand207({
+var followCommand = defineCommand208({
   meta: {
     name: "follow",
     description: 'Follow a brand to track ALL its ads \u2014 every platform and country. --platform is how we read your input, not a limit. A domain tracks both Meta + LinkedIn. Example: baker winning-ads follow "deel.com" --platform meta'
@@ -43327,7 +43810,7 @@ var followCommand = defineCommand207({
 });
 
 // src/commands/winning-ads/follow-competitors.ts
-import { defineCommand as defineCommand208 } from "citty";
+import { defineCommand as defineCommand209 } from "citty";
 var PLATFORMS2 = ["meta", "linkedin"];
 var BATCH_TIMEOUT_MS = 3e5;
 function buildFollowBatchBody(input) {
@@ -43360,7 +43843,7 @@ registerSchema({
     }
   }
 });
-var followCompetitorsCommand = defineCommand208({
+var followCompetitorsCommand = defineCommand209({
   meta: {
     name: "follow-competitors",
     description: 'Follow many brands at once by domain \u2014 add every competitor in one call. Example: baker winning-ads follow-competitors "deel.com,notion.so,hubspot.com"'
@@ -43435,7 +43918,7 @@ var followCompetitorsCommand = defineCommand208({
 });
 
 // src/commands/winning-ads/following.ts
-import { defineCommand as defineCommand209 } from "citty";
+import { defineCommand as defineCommand210 } from "citty";
 registerSchema({
   command: "winning-ads.following",
   description: "List the brands you follow in your ad-dna library, with each one's status (ready vs still adding) and cached ad counts.",
@@ -43468,7 +43951,7 @@ function followingNormalizer(record, full) {
     platforms: Array.isArray(record.platforms) ? record.platforms : []
   };
 }
-var followingCommand = defineCommand209({
+var followingCommand = defineCommand210({
   meta: {
     name: "following",
     description: "List brands you follow, with status (ready / adding\u2026) and cached counts. Example: baker winning-ads following --output md"
@@ -43503,7 +43986,7 @@ var followingCommand = defineCommand209({
 });
 
 // src/commands/winning-ads/patterns.ts
-import { defineCommand as defineCommand210 } from "citty";
+import { defineCommand as defineCommand211 } from "citty";
 registerSchema({
   command: "winning-ads.patterns",
   description: "Mine what separates two cohorts of ads: pass a comma-list of winning ad ids (--winners) and a comma-list of weaker ad ids (--duds). Returns the discriminating DNA fields.",
@@ -43542,7 +44025,7 @@ function discriminatorRow(record) {
     top_values_duds: Array.isArray(record.top_values_b) ? record.top_values_b.join(", ") : ""
   };
 }
-var patternsCommand = defineCommand210({
+var patternsCommand = defineCommand211({
   meta: {
     name: "patterns",
     description: "Discover what separates winning ads from weak ones. Example: baker winning-ads patterns --winners a_1,a_2,a_3 --duds a_9,a_8 --output md"
@@ -43598,7 +44081,7 @@ var patternsCommand = defineCommand210({
 });
 
 // src/commands/winning-ads/search.ts
-import { defineCommand as defineCommand211 } from "citty";
+import { defineCommand as defineCommand212 } from "citty";
 registerSchema({
   command: "winning-ads.search",
   description: "Search the ad-dna corpus of scored winning ads. Returns a lean shortlist (advertiser, summary, scores, media_url) to pick a reference to reproduce.",
@@ -43706,7 +44189,7 @@ function buildSearchBody2(args) {
   }
   return body;
 }
-var searchCommand5 = defineCommand211({
+var searchCommand5 = defineCommand212({
   meta: {
     name: "search",
     description: "Search winning reference ads. Example: baker winning-ads search 'B2B SaaS before/after AI automation' --platform meta --format static --winner-category winner --exclude-advertiser adv_123 --output md"
@@ -43821,7 +44304,7 @@ var searchCommand5 = defineCommand211({
 });
 
 // src/commands/winning-ads/seeds.ts
-import { defineCommand as defineCommand212 } from "citty";
+import { defineCommand as defineCommand213 } from "citty";
 function leanRow(r) {
   return {
     key: r.key,
@@ -43849,7 +44332,7 @@ function makeSeedCommand(opts) {
       limit: { type: "number", description: "Max keys 1-100 (default 20)", required: false, default: 20 }
     }
   });
-  return defineCommand212({
+  return defineCommand213({
     meta: { name: opts.name, description: opts.description },
     args: {
       platform: { type: "string", description: "Single platform to segment on", required: false },
@@ -43898,7 +44381,7 @@ var formatsCommand = makeSeedCommand({
 });
 
 // src/commands/winning-ads/unfollow.ts
-import { defineCommand as defineCommand213 } from "citty";
+import { defineCommand as defineCommand214 } from "citty";
 registerSchema({
   command: "winning-ads.unfollow",
   description: "Stop following a brand \u2014 removes it from your ad-dna library by advertiser id.",
@@ -43906,7 +44389,7 @@ registerSchema({
     advertiser: { type: "string", description: "Advertiser id to unfollow", required: true }
   }
 });
-var unfollowCommand = defineCommand213({
+var unfollowCommand = defineCommand214({
   meta: {
     name: "unfollow",
     description: "Stop following a brand by advertiser id. Example: baker winning-ads unfollow adv_123"
@@ -43927,7 +44410,7 @@ var unfollowCommand = defineCommand213({
 });
 
 // src/commands/winning-ads/winners.ts
-import { defineCommand as defineCommand214 } from "citty";
+import { defineCommand as defineCommand215 } from "citty";
 registerSchema({
   command: "winning-ads.winners",
   description: "Top winning ads for one advertiser id (from `advertisers` or `following`). Returns lean winner cards; add --full for DNA + longevity.",
@@ -43937,7 +44420,7 @@ registerSchema({
     platform: { type: "string", description: "Filter to a single platform: meta|linkedin", required: false }
   }
 });
-var winnersCommand = defineCommand214({
+var winnersCommand = defineCommand215({
   meta: {
     name: "winners",
     description: "Top winning ads for a specific advertiser id. Example: baker winning-ads winners adv_123 --top 15 --output md"
@@ -43987,7 +44470,7 @@ var winnersCommand = defineCommand214({
 });
 
 // src/commands/winning-ads/index.ts
-var winningAdsCommand = defineCommand215({
+var winningAdsCommand = defineCommand216({
   meta: {
     name: "winning-ads",
     description: `Search the ad-dna corpus of scored "winning" ads for reference creatives to reproduce, and manage the brands your library tracks. Proxied through the Baker backend (BAKER_API_KEY) \u2014 no separate token needed.
@@ -44042,6 +44525,172 @@ Full guide: __tooling__/docs/tools/baker/winning-ads.md`
   }
 });
 
+// src/unknown-flags.ts
+var ALWAYS_ACCEPTED = /* @__PURE__ */ new Set(["help", "h", "version"]);
+function subCommandsOf(command) {
+  const sub = command.subCommands;
+  return sub && typeof sub === "object" ? sub : null;
+}
+function argsOf(command) {
+  const args = command.args;
+  return args && typeof args === "object" ? args : null;
+}
+function resolveCommand2(root, argv) {
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    if (!subCommands) {
+      break;
+    }
+    const next = subCommands[token];
+    if (next === void 0) {
+      break;
+    }
+    if (typeof next !== "object") {
+      return { command, resolved: false };
+    }
+    command = next;
+  }
+  return { command, resolved: true };
+}
+function typeOf(def) {
+  return def && typeof def === "object" ? def.type : void 0;
+}
+function acceptedNames(command) {
+  const args = argsOf(command);
+  if (!args) {
+    return null;
+  }
+  const names = new Set(ALWAYS_ACCEPTED);
+  for (const [name, def] of Object.entries(args)) {
+    if (typeOf(def) === "positional") {
+      continue;
+    }
+    for (const spelling of [name, kebab(name), camel(name)]) {
+      names.add(spelling);
+      if (typeOf(def) === "boolean") {
+        names.add(`no-${spelling}`);
+      }
+    }
+  }
+  return names;
+}
+function kebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function camel(name) {
+  return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function findUnknownFlags(root, argv) {
+  const { command, resolved } = resolveCommand2(root, argv);
+  if (!resolved) {
+    return [];
+  }
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return [];
+  }
+  const unknown = [];
+  for (const token of argv) {
+    if (token === "--") {
+      break;
+    }
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    const name = token.slice(2).split("=")[0] ?? "";
+    if (name.length > 0 && !accepted.has(name) && !unknown.includes(token)) {
+      unknown.push(token);
+    }
+  }
+  return unknown;
+}
+function closestFlag(unknown, command) {
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return null;
+  }
+  const name = unknown.replace(/^--/, "").split("=")[0] ?? "";
+  const scored = [...accepted].filter((candidate) => !ALWAYS_ACCEPTED.has(candidate)).map((candidate) => ({
+    candidate,
+    prefix: sharedPrefix(name, candidate),
+    distance: editDistance(name, candidate)
+  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= 3).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
+  return scored[0] ? `--${scored[0].candidate}` : null;
+}
+function sharedPrefix(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) {
+    i++;
+  }
+  return i;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution));
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function commandFor(root, argv) {
+  const { command, resolved } = resolveCommand2(root, argv);
+  return resolved ? command : null;
+}
+function unknownFlagEnvelope(unknown, commandPath, suggestion) {
+  const list = unknown.join(", ");
+  return {
+    ok: false,
+    error: {
+      code: "UNKNOWN_ARGUMENT",
+      message: `${list} ${unknown.length > 1 ? "are not options" : "is not an option"} of \`baker ${commandPath}\`.`,
+      fix: {
+        action: "check_schema",
+        explanation: (suggestion ? `Did you mean ${suggestion}? ` : "") + `Run \`baker schema ${commandPath}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
+      },
+      retryable: false
+    }
+  };
+}
+function commandPathOf(root, argv) {
+  const path38 = [];
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    const next = subCommands?.[token];
+    if (next === void 0 || typeof next !== "object") {
+      break;
+    }
+    path38.push(token);
+    command = next;
+  }
+  return path38.join(" ");
+}
+function refuseUnknownFlags(root, argv) {
+  const unknown = findUnknownFlags(root, argv);
+  if (unknown.length === 0) {
+    return;
+  }
+  const command = commandFor(root, argv);
+  const first = unknown[0];
+  const suggestion = command && first ? closestFlag(first, command) : null;
+  process.stdout.write(
+    `${JSON.stringify(unknownFlagEnvelope(unknown, commandPathOf(root, argv), suggestion), null, 2)}
+`
+  );
+  process.exit(1);
+}
+
 // src/version.ts
 import { readFileSync as readFileSync14 } from "fs";
 function packageJsonUrl() {
@@ -44059,7 +44708,7 @@ function getCliVersion() {
 }
 
 // src/cli.ts
-var main = defineCommand216({
+var main = defineCommand217({
   meta: {
     name: "baker",
     version: getCliVersion(),
@@ -44101,5 +44750,6 @@ Introspection: Run 'baker schema <command>' to inspect argument schemas.`
 });
 installStreamTaps();
 logInvocation(process.argv.slice(2));
+refuseUnknownFlags(main, process.argv.slice(2));
 runMain(main);
 //# sourceMappingURL=cli.js.map