@koda-sl/baker-cli 0.551.0 → 0.552.0

package/dist/chunk-CRORJLBL.js

@@ -0,0 +1,91 @@
+import {
+  definitionPlatformOf,
+  parseDefinitionDelivery,
+  resolveDelivery,
+  resolveFormatList
+} from "./chunk-26ALFAKU.js";
+import {
+  AD_PLACEMENTS
+} from "./chunk-MCJ5I5LR.js";
+import {
+  CAPABILITY_SURFACES
+} from "./chunk-NSBNIPIW.js";
+import {
+  apiPost
+} from "./chunk-OQ7CLFEL.js";
+
+// src/commands/canvas/scaffold-delivery.ts
+var flagText = (value) => typeof value === "string" || typeof value === "number" ? String(value).trim() || void 0 : void 0;
+function deliveryInputOf(flags, definition, idea) {
+  const platformsFlag = flagText(flags.platforms);
+  const legacyPlatform = flagText(flags.platform);
+  const legacyPlacements = flagText(flags.placements);
+  const aspect = flagText(flags.aspect);
+  const formatsFlag = flagText(flags.formats);
+  const targetAdSet = flagText(flags["target-adset"]);
+  return {
+    ...platformsFlag ? { platformsFlag } : {},
+    ...legacyPlatform ? { legacyPlatform } : {},
+    ...legacyPlacements ? { legacyPlacements } : {},
+    ...aspect ? { aspect } : {},
+    ...formatsFlag ? { formatsFlag } : {},
+    ...idea && idea.length > 0 ? { idea } : {},
+    definition,
+    ...targetAdSet ? { targetAdSet } : {}
+  };
+}
+function namesDelivery(flags) {
+  return [flags.platforms, flags.platform, flags.placements, flags.formats].some((f) => flagText(f) !== void 0);
+}
+var SURFACE_PLATFORMS = {
+  "meta-ads": "meta",
+  "linkedin-ads": "linkedin",
+  "google-ads": "google_demandgen",
+  "x-ads": "x",
+  "chatgpt-ads": "chatgpt"
+};
+async function connectedAdPlatforms() {
+  try {
+    const response = await apiPost("/api/capabilities", {}, { timeoutMs: 15e3 });
+    return response.data.surfaces.filter((s) => s.connected && CAPABILITY_SURFACES.includes(s.surface)).flatMap((s) => SURFACE_PLATFORMS[s.surface] ? [SURFACE_PLATFORMS[s.surface]] : []);
+  } catch {
+    return [];
+  }
+}
+async function scaffoldDelivery(flags, definitionText, idea) {
+  const definition = definitionText === null ? null : parseDefinitionDelivery(definitionText);
+  const input = deliveryInputOf(flags, definition, idea);
+  const resolved = resolveDelivery(input);
+  if (resolved.ok || resolved.error.code !== "platform_required") return resolved;
+  return resolveDelivery({ ...input, connected: await connectedAdPlatforms() });
+}
+function deliveryDefinitionFields(delivery) {
+  const platforms = delivery.platforms.map((p) => p.trim());
+  return {
+    // The collection names whole platforms; a placement named alone records its platform.
+    platforms: [...new Set(platforms.map(platformOfName))],
+    platform: definitionPlatformOf(platforms[0] ?? ""),
+    formats: resolveFormatList(delivery.formats)
+  };
+}
+function platformOfName(name) {
+  return AD_PLACEMENTS.find((p) => p.id === name)?.platform ?? name;
+}
+function deliveryNote(delivery, renderRatio) {
+  const from = {
+    flag: "as asked",
+    idea: "from the idea",
+    definition: "from _definition.md",
+    legacy_definition: "from _definition.md's platform",
+    adset: "from its Meta ad set"
+  };
+  return `Made for ${delivery.platforms.join(", ")} (${from[delivery.source]}): delivers ${delivery.formats.join(", ")}, the ${delivery.lead} designed first (rendered at ${renderRatio}) and every other size re-laid out from it.`;
+}
+
+export {
+  namesDelivery,
+  scaffoldDelivery,
+  deliveryDefinitionFields,
+  deliveryNote
+};
+//# sourceMappingURL=chunk-CRORJLBL.js.map

package/dist/chunk-CTX4RST4.js

@@ -0,0 +1,287 @@
+import {
+  failWriteValidation,
+  parseDateFlag,
+  parseMoneyFlag
+} from "./chunk-BXHS4OIS.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+
+// src/commands/ads/meta/delivery-flags.ts
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function frequencyCapFlag(value) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const match = /^(\d+)\s*\/\s*(\d+)\s*d?$/i.exec(raw.trim());
+  if (!match) {
+    failWriteValidation(
+      `--frequency-cap takes N/D \u2014 at most N impressions per person every D days, e.g. 2/7 (got "${raw}")`
+    );
+  }
+  return [{ event: "IMPRESSIONS", interval_days: Number(match[2]), max_frequency: Number(match[1]) }];
+}
+var DAY_INDEX = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+function dayIndex(name, flag) {
+  const index = DAY_INDEX[name.slice(0, 3).toLowerCase()];
+  if (index === void 0) {
+    failWriteValidation(`${flag}: "${name}" is not a day \u2014 use Mon, Tue, \u2026 Sun`);
+  }
+  return index;
+}
+function scheduleDays(spec) {
+  if (/^(daily|every ?day|all)$/i.test(spec)) {
+    return [0, 1, 2, 3, 4, 5, 6];
+  }
+  return spec.split(",").flatMap((part) => {
+    const [from, to] = part.split("-").map((day) => day.trim());
+    if (!from) {
+      return [];
+    }
+    const start = dayIndex(from, "--schedule");
+    if (!to) {
+      return [start];
+    }
+    const end = dayIndex(to, "--schedule");
+    const days = [];
+    for (let day = start; days.length < 7; day = (day + 1) % 7) {
+      days.push(day);
+      if (day === end) break;
+    }
+    return days;
+  });
+}
+function hourMinute(value) {
+  const [hours = "", minutes = "0"] = value.split(":");
+  return Number(hours) * 60 + Number(minutes);
+}
+function scheduleBlock(raw, timezone) {
+  const match = /^(.+?)\s+(\d{1,2}(?::\d{2})?)\s*-\s*(\d{1,2}(?::\d{2})?)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--schedule takes "<days> <from>-<to>", e.g. "Mon-Fri 09-18" or "sat,sun 10:00-14:00" (got "${raw}")`
+    );
+  }
+  return {
+    days: scheduleDays(match[1]),
+    start_minute: hourMinute(match[2]),
+    end_minute: hourMinute(match[3]),
+    timezone_type: timezone
+  };
+}
+function dayPartingFromFlags(args, rawArgs) {
+  const blocks = repeatedValues(rawArgs, "schedule", args.schedule).map((block) => {
+    const { timezone_type: _clock, ...rest } = scheduleBlock(block, "USER");
+    return rest;
+  });
+  return blocks.length > 0 ? blocks : void 0;
+}
+function scheduleTimezone(value) {
+  const raw = text(value)?.toLowerCase();
+  if (raw === void 0 || raw === "viewer" || raw === "user") {
+    return "USER";
+  }
+  if (raw === "account" || raw === "advertiser") {
+    return "ADVERTISER";
+  }
+  failWriteValidation(`--schedule-timezone takes viewer or account (got "${raw}")`);
+}
+var ATTRIBUTION_EVENTS = {
+  click: "CLICK_THROUGH",
+  view: "VIEW_THROUGH",
+  engaged_view: "ENGAGED_VIDEO_VIEW",
+  engaged_video_view: "ENGAGED_VIDEO_VIEW"
+};
+function attributionFlag(value) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  return raw.split(",").map((window) => {
+    const match = /^(\d+)d_([a-z_]+)$/i.exec(window.trim());
+    const event = match?.[2] ? ATTRIBUTION_EVENTS[match[2].toLowerCase()] : void 0;
+    if (!match || !event) {
+      failWriteValidation(`--attribution takes windows like 7d_click,1d_view,1d_engaged_view (got "${window}")`);
+    }
+    return { event_type: event, window_days: Number(match[1]) };
+  });
+}
+function numberArg(value, flag) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    failWriteValidation(`${flag} must be a number`);
+  }
+  return n;
+}
+function adSetDeliveryFromFlags(args, rawArgs) {
+  const timezone = scheduleTimezone(args["schedule-timezone"]);
+  const blocks = repeatedValues(rawArgs, "schedule", args.schedule).map((block) => scheduleBlock(block, timezone));
+  if (args["schedule-timezone"] !== void 0 && blocks.length === 0) {
+    failWriteValidation(
+      "--schedule-timezone says whose clock --schedule follows, so it goes with --schedule \u2014 pass the hours again with it"
+    );
+  }
+  const delivery = {
+    minRoas: numberArg(args["min-roas"], "--min-roas"),
+    frequency_control_specs: frequencyCapFlag(args["frequency-cap"]),
+    adset_schedule: blocks.length > 0 ? blocks : void 0,
+    pacing: text(args.pacing)?.toLowerCase(),
+    dailyMinSpendTarget: parseMoneyFlag(args["daily-min-spend"], args.currency, "--daily-min-spend"),
+    dailySpendCap: parseMoneyFlag(args["daily-spend-cap"], args.currency, "--daily-spend-cap"),
+    lifetimeMinSpendTarget: parseMoneyFlag(args["lifetime-min-spend"], args.currency, "--lifetime-min-spend"),
+    lifetimeSpendCap: parseMoneyFlag(args["lifetime-spend-cap"], args.currency, "--lifetime-spend-cap"),
+    is_dynamic_creative: args["dynamic-creative"] === void 0 ? void 0 : Boolean(args["dynamic-creative"]),
+    attribution_spec: attributionFlag(args.attribution)
+  };
+  return Object.fromEntries(Object.entries(delivery).filter(([, value]) => value !== void 0));
+}
+function budgetBoost(raw, currency) {
+  const match = /^(.+?)\.\.(.+?)=\+?(\d+(?:\.\d{1,3})?)(%?)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--budget-boost takes START..END=+AMOUNT or START..END=+PERCENT%, e.g. 2027-11-27T00:00Z..2027-11-28T00:00Z=+50% (got "${raw}")`
+    );
+  }
+  const period = {
+    time_start: parseDateFlag(match[1], "--budget-boost start"),
+    time_end: parseDateFlag(match[2], "--budget-boost end")
+  };
+  return match[4] === "%" ? { ...period, increasePercent: Number(match[3]) } : { ...period, increase: parseMoneyFlag(match[3], currency, "--budget-boost") };
+}
+function budgetBoostsFromFlags(args, rawArgs) {
+  const boosts = repeatedValues(rawArgs, "budget-boost", args["budget-boost"]);
+  return boosts.length > 0 ? boosts.map((boost) => budgetBoost(boost, args.currency)) : void 0;
+}
+function boostMove(raw) {
+  const match = /^(\d+)=(.+?)\.\.(.+)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--move-boost takes ID=START..END, e.g. 1633135568548763=2027-11-27T06:00Z..2027-11-27T12:00Z (got "${raw}")`
+    );
+  }
+  return {
+    id: match[1],
+    time_start: parseDateFlag(match[2], "--move-boost start"),
+    time_end: parseDateFlag(match[3], "--move-boost end")
+  };
+}
+function boostEditsFromFlags(args, rawArgs) {
+  const removed = repeatedValues(rawArgs, "remove-boost", args["remove-boost"]).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  const moved = repeatedValues(rawArgs, "move-boost", args["move-boost"]);
+  return {
+    ...removed.length > 0 ? { removeBoosts: removed } : {},
+    ...moved.length > 0 ? { moveBoosts: moved.map(boostMove) } : {}
+  };
+}
+var boostEditArgs = {
+  "remove-boost": {
+    type: "string",
+    description: "Take one budget boost away, by its id from `baker ads meta high-demand-periods --campaign-id <id>` \u2014 repeatable or comma-separated. The others stay."
+  },
+  "move-boost": {
+    type: "string",
+    description: "Move one budget boost to another window, keeping its raise: ID=START..END, repeatable, at least 3 hours, on quarter hours. Meta has no boost update, so publish adds the same raise on the new window, then deletes the old boost. Example: --move-boost 1633135568548763=2027-11-27T06:00Z..2027-11-27T12:00Z"
+  }
+};
+var adSetDeliveryArgs = {
+  "min-roas": {
+    type: "string",
+    description: "Minimum ROAS for LOWEST_COST_WITH_MIN_ROAS bidding, as a multiple of spend: 2.5 = 250%. Needs --optimization-goal VALUE. Under a min-ROAS campaign budget every ad set needs its own. Example: --bid-strategy LOWEST_COST_WITH_MIN_ROAS --min-roas 2.5"
+  },
+  "frequency-cap": {
+    type: "string",
+    description: "At most N impressions per person every D days, as N/D \u2014 REACH and THRUPLAY goals only. Example: --frequency-cap 2/7"
+  },
+  schedule: {
+    type: "string",
+    description: 'Run ads only in these hours (dayparting), repeatable: "<days> <from>-<to>", whole hours. Needs --lifetime-budget and --end. Example: --schedule "Mon-Fri 09-18" --schedule "Sat 10-14"'
+  },
+  "schedule-timezone": {
+    type: "string",
+    description: "Whose clock --schedule follows: viewer (default) or account"
+  },
+  pacing: {
+    type: "string",
+    description: "standard (default) | no_pacing (accelerated \u2014 spends as fast as it can; LOWEST_COST_WITH_BID_CAP only) | day_parting (set by --schedule)"
+  },
+  "daily-min-spend": {
+    type: "string",
+    description: "Ad set spend limit under a DAILY campaign budget: spend at least this per day (best effort)"
+  },
+  "daily-spend-cap": {
+    type: "string",
+    description: "Ad set spend limit under a DAILY campaign budget: spend at most this per day. Example: --daily-spend-cap 15"
+  },
+  "lifetime-min-spend": {
+    type: "string",
+    description: "Ad set spend limit under a LIFETIME campaign budget: spend at least this in total"
+  },
+  "lifetime-spend-cap": {
+    type: "string",
+    description: "Ad set spend limit under a LIFETIME campaign budget: spend at most this in total"
+  },
+  attribution: {
+    type: "string",
+    description: "Attribution windows Meta optimizes on: 1d_click or 7d_click, plus 1d_view and/or 1d_engaged_view \u2014 conversion goals only; LINK_CLICKS, LANDING_PAGE_VIEWS and REACH take 1d_click alone. Fixed when the ad set is created: Meta refuses a change on a live ad set. Example: --attribution 7d_click,1d_view"
+  }
+};
+var budgetBoostArg = {
+  "budget-boost": {
+    type: "string",
+    description: "Raise the daily budget for a high-demand period, repeatable: START..END=+AMOUNT or START..END=+PERCENT% (max 800%), at least 3 hours, on quarter hours, all amounts or all percentages. Needs --daily-budget in the same command (the current one, on update). Example: --budget-boost 2027-11-27T00:00Z..2027-11-28T00:00Z=+50%"
+  }
+};
+var CLEAR_FLAGS = {
+  "daily-min-spend": "dailyMinSpendTarget",
+  "daily-spend-cap": "dailySpendCap",
+  "lifetime-min-spend": "lifetimeMinSpendTarget",
+  "lifetime-spend-cap": "lifetimeSpendCap",
+  schedule: "adset_schedule",
+  boosts: "budgetSchedules",
+  "budget-boost": "budgetSchedules"
+};
+var NOT_CLEARABLE = {
+  "min-roas": "a ROAS floor goes with ROAS goal bidding \u2014 switch --bid-strategy (e.g. LOWEST_COST_WITHOUT_CAP) and Baker drops the floor",
+  "frequency-cap": "Meta keeps a frequency cap on a reach ad set whatever is sent (an empty cap is accepted and ignored) \u2014 set another with --frequency-cap"
+};
+function clearFromFlags(rawArgs, entity) {
+  const names = repeatedValues(rawArgs, "clear", void 0).flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter(Boolean);
+  if (names.length === 0) return void 0;
+  const fields = names.map((name) => {
+    const why = NOT_CLEARABLE[name];
+    if (why) throw new Error(`--clear ${name}: ${why}`);
+    const field = CLEAR_FLAGS[name];
+    if (!field || entity === "campaign" && field !== "budgetSchedules") {
+      const takes = entity === "campaign" ? "boosts" : Object.keys(CLEAR_FLAGS).join(", ");
+      throw new Error(`--clear takes ${takes} \u2014 not "${name}"`);
+    }
+    return field;
+  });
+  return [...new Set(fields)];
+}
+var clearArg = {
+  clear: {
+    type: "string",
+    description: "Take a delivery control away (repeatable or comma-separated): daily-min-spend, daily-spend-cap, lifetime-min-spend, lifetime-spend-cap, schedule (back to standard pacing), boosts (every budget boost it has now). A ROAS floor goes by switching --bid-strategy; Meta keeps a reach ad set's frequency cap."
+  }
+};
+
+export {
+  dayPartingFromFlags,
+  adSetDeliveryFromFlags,
+  budgetBoostsFromFlags,
+  boostEditsFromFlags,
+  boostEditArgs,
+  adSetDeliveryArgs,
+  budgetBoostArg,
+  clearFromFlags,
+  clearArg
+};
+//# sourceMappingURL=chunk-CTX4RST4.js.map

package/dist/chunk-DF7IGB3K.js

@@ -0,0 +1,296 @@
+import {
+  DIRECT_ROUTE,
+  captureProxyCredentials,
+  childEnvWith,
+  plannedRoutes,
+  shouldEscalate
+} from "./chunk-O4OPH3ZE.js";
+
+// src/lib/vimeoCookie.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+var COOKIE_NAME = "vimeo";
+async function writeVimeoCookieFile(cookie, workDir) {
+  const value = cookie?.trim();
+  if (!value) return void 0;
+  const expires = Math.floor(Date.now() / 1e3) + 365 * 24 * 60 * 60;
+  const jar = [
+    "# Netscape HTTP Cookie File",
+    [".vimeo.com", "TRUE", "/", "TRUE", String(expires), COOKIE_NAME, value].join("	"),
+    ""
+  ].join("\n");
+  const filePath = path.join(workDir, "vimeo-cookies.txt");
+  await writeFile(filePath, jar, { mode: 384 });
+  return filePath;
+}
+var VIMEO_AUTH_SIGNATURES = ["oauth token", "only works when logged-in", "unable to fetch new oauth tokens"];
+function isVimeoAuthFailure(detail) {
+  const haystack = detail.toLowerCase();
+  if (!haystack.includes("[vimeo]")) return false;
+  return VIMEO_AUTH_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+
+// src/lib/ytDlpSignal.ts
+var HTTP_ERROR = /HTTP Error (\d{3})/i;
+var CHALLENGE_PHRASES = [
+  "sign in to confirm you're not a bot",
+  "sign in to confirm you\u2019re not a bot",
+  "confirm you are not a bot",
+  "unusual traffic",
+  "captcha"
+];
+var NOT_A_BLOCK_PHRASES = ["private video", "video unavailable", "members-only", "this video is available to"];
+var PROXY_TUNNEL_FAILURE = /tunnel connection failed: 407|proxy authentication required|http error 407/i;
+function ytDlpBlockSignal(stderr) {
+  const text = stderr.toLowerCase();
+  if (PROXY_TUNNEL_FAILURE.test(stderr)) return { status: 407 };
+  if (NOT_A_BLOCK_PHRASES.some((phrase) => text.includes(phrase))) return {};
+  const status = HTTP_ERROR.exec(stderr);
+  if (status) return { status: Number(status[1]) };
+  if (CHALLENGE_PHRASES.some((phrase) => text.includes(phrase))) return { challenge: true };
+  return {};
+}
+
+// src/lib/ytDlp.ts
+import { spawn } from "child_process";
+import { readdir, readFile } from "fs/promises";
+import path2 from "path";
+
+// src/lib/ytDlpFormat.ts
+function videoFormatArgs(maxResolution) {
+  const sort = maxResolution ? ["-S", `res:${maxResolution}`] : [];
+  return ["--format", "bv*+ba/b", ...sort, "--merge-output-format", "mp4"];
+}
+
+// src/lib/ytDlpPlayerClient.ts
+var YOUTUBE_FALLBACK_CLIENT_ARGS = ["--extractor-args", "youtube:player_client=android"];
+var MEDIA_FETCH_REFUSED = "unable to download video data";
+var YOUTUBE_HOSTS = ["youtube.com", "youtu.be"];
+function isYouTube(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return YOUTUBE_HOSTS.some((known) => host === known || host.endsWith(`.${known}`));
+}
+function needsPlayerClientRetry(url, stderr) {
+  return isYouTube(url) && stderr.toLowerCase().includes(MEDIA_FETCH_REFUSED);
+}
+
+// src/lib/ytDlp.ts
+var YT_DLP_BIN = "yt-dlp";
+var YT_DLP_TIMEOUT_MS = 10 * 60 * 1e3;
+var YT_DLP_PROBE_TIMEOUT_MS = 60 * 1e3;
+var TRUST_SYSTEM_CERTS = ["--compat-options", "no-certifi"];
+var YtDlpError = class extends Error {
+  constructor(message, stderrTail) {
+    super(message);
+    this.stderrTail = stderrTail;
+    this.name = "YtDlpError";
+  }
+};
+function tail(text, maxLines) {
+  return text.split("\n").slice(-maxLines).join("\n");
+}
+async function runYtDlp(args) {
+  const outTemplate = path2.join(args.workDir, "out.%(ext)s");
+  const infoPath = path2.join(args.workDir, "out.info.json");
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-progress",
+    "--no-warnings",
+    "--quiet",
+    "--write-info-json",
+    ...TRUST_SYSTEM_CERTS,
+    "-o",
+    outTemplate
+  ];
+  if (args.audioOnly) {
+    argv.push("-x", "--audio-format", "m4a");
+  } else {
+    argv.push(...videoFormatArgs(args.maxHeight));
+  }
+  const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.workDir);
+  if (cookieFile) argv.push("--cookies", cookieFile);
+  args.onLog?.(`yt-dlp: downloading ${args.audioOnly ? "audio" : "video"}`);
+  const timeoutMs = args.timeoutMs ?? YT_DLP_TIMEOUT_MS;
+  const { code, stderr, tier, reducedQuality } = await downloadWithClientFallback({
+    url: args.url,
+    argv,
+    onLog: args.onLog,
+    ladder: (attemptArgv) => runViaLadder({ url: args.url, argv: attemptArgv, timeoutMs, onLog: args.onLog, country: args.country }),
+    repeat: (attemptArgv, route) => spawnAndWait(YT_DLP_BIN, attemptArgv, timeoutMs, { extraEnv: proxyEnvFor(route) })
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  const files = await readdir(args.workDir);
+  const wanted = args.audioOnly ? ".m4a" : ".mp4";
+  const downloaded = files.find((f) => f.startsWith("out.") && f.endsWith(wanted));
+  if (!downloaded) {
+    throw new YtDlpError(`yt-dlp finished but produced no ${wanted} file (saw: ${files.join(", ")})`, "");
+  }
+  let info = {};
+  try {
+    info = JSON.parse(await readFile(infoPath, "utf-8"));
+  } catch {
+  }
+  return { filePath: path2.join(args.workDir, downloaded), info, tier, reducedQuality };
+}
+async function probeYtDlp(args) {
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-warnings",
+    "--dump-single-json",
+    "--skip-download",
+    // Without this the probe fails wherever the *download* would fail, which
+    // defeats the point of probing: yt-dlp still runs format selection for
+    // `--dump-single-json`, so a binary too old to read a site's format list
+    // exits "Requested format is not available" and we learn nothing — measured
+    // against a stale build, which returned full metadata the moment this flag
+    // was added. Duration and id come from the page, not from a format.
+    "--ignore-no-formats-error",
+    ...TRUST_SYSTEM_CERTS
+  ];
+  if (args.cookieDir) {
+    const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.cookieDir);
+    if (cookieFile) argv.push("--cookies", cookieFile);
+  }
+  let stdout = "";
+  const { code, stderr, tier } = await walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: async (route) => {
+      const result = await spawnAndWait(YT_DLP_BIN, argv, args.timeoutMs ?? YT_DLP_PROBE_TIMEOUT_MS, {
+        extraEnv: proxyEnvFor(route),
+        captureStdout: true
+      });
+      stdout = result.stdout ?? "";
+      return result;
+    },
+    onLog: args.onLog,
+    country: args.country
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new YtDlpError("yt-dlp returned metadata that could not be read", tail(stdout, 5));
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new YtDlpError("yt-dlp returned no metadata for that link", tail(stderr, 40));
+  }
+  return { info: parsed, tier };
+}
+function isAudioOnly(info) {
+  return info.vcodec === "none";
+}
+function durationSeconds(info) {
+  const raw = info.duration;
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : void 0;
+}
+function canonicalUrl(info) {
+  const raw = info.webpage_url;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+async function walkYtDlpLadder(args) {
+  const routes = plannedRoutes(args.url, args.credentials, args.country ? { country: args.country } : void 0);
+  let last = { code: -1, stderr: "", tier: "direct", route: DIRECT_ROUTE };
+  for (const route of routes) {
+    const tier = route.kind === "proxy" ? route.tier : "direct";
+    if (route.kind === "proxy") args.onLog?.(`yt-dlp: retrying via ${tier}`);
+    last = { ...await args.attempt(route), tier, route };
+    if (last.code === 0) return last;
+    if (!shouldEscalate(ytDlpBlockSignal(last.stderr))) return last;
+  }
+  return last;
+}
+async function downloadWithClientFallback(args) {
+  const first = await args.ladder(args.argv);
+  if (first.code === 0 || !needsPlayerClientRetry(args.url, first.stderr)) {
+    return { ...first, reducedQuality: false };
+  }
+  args.onLog?.("yt-dlp: retrying with the fallback player client");
+  const again = await args.repeat([...args.argv, ...YOUTUBE_FALLBACK_CLIENT_ARGS], first.route);
+  return { ...again, tier: first.tier, route: first.route, reducedQuality: again.code === 0 };
+}
+function runViaLadder(args) {
+  return walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: (route) => spawnAndWait(YT_DLP_BIN, args.argv, args.timeoutMs, { extraEnv: proxyEnvFor(route) }),
+    onLog: args.onLog,
+    country: args.country
+  });
+}
+function proxyEnvFor(route) {
+  if (route.kind !== "proxy") return void 0;
+  const uri = new URL(route.server);
+  uri.username = encodeURIComponent(route.username);
+  uri.password = encodeURIComponent(route.password);
+  return {
+    HTTP_PROXY: uri.toString(),
+    HTTPS_PROXY: uri.toString(),
+    http_proxy: uri.toString(),
+    https_proxy: uri.toString()
+  };
+}
+function spawnAndWait(bin, argv, timeoutMs, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, argv, {
+      stdio: ["ignore", "pipe", "pipe"],
+      // `childEnvWith` because `spawn`'s `env` REPLACES the environment rather
+      // than extending it — passing only the additions would strip PATH.
+      ...options.extraEnv ? { env: childEnvWith(options.extraEnv) } : {}
+    });
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    let stderrLen = 0;
+    const MAX_STDERR = 256 * 1024;
+    child.stdout.on("data", (chunk) => {
+      if (options.captureStdout) stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrLen < MAX_STDERR) {
+        stderrChunks.push(chunk);
+        stderrLen += chunk.length;
+      }
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`failed to spawn "${bin}" \u2014 ${err.message}`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        code: code ?? -1,
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        ...options.captureStdout ? { stdout: Buffer.concat(stdoutChunks).toString("utf-8") } : {}
+      });
+    });
+  });
+}
+
+export {
+  isVimeoAuthFailure,
+  ytDlpBlockSignal,
+  YT_DLP_BIN,
+  YtDlpError,
+  runYtDlp,
+  probeYtDlp,
+  isAudioOnly,
+  durationSeconds,
+  canonicalUrl
+};
+//# sourceMappingURL=chunk-DF7IGB3K.js.map