@koda-sl/baker-cli 0.553.0 → 0.555.0

package/dist/chunk-EENYLJUN.js

@@ -0,0 +1,225 @@
+import {
+  metaDraftOpInputSchema
+} from "./chunk-GC5P4KWY.js";
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-QY7EK6Q4.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  adCopyHints,
+  booleanWordPositionalError,
+  payloadFix
+} from "./chunk-CDTAKCJR.js";
+import {
+  withHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-QYH2UZAK.js";
+import {
+  describeOpPayload
+} from "./chunk-R7XDGNZD.js";
+import {
+  apiPost
+} from "./chunk-GFWWHCBF.js";
+import {
+  requireChatId
+} from "./chunk-45D6WRCJ.js";
+import {
+  payloadArg
+} from "./chunk-CCYZJMZ7.js";
+
+// src/commands/ads/meta/write-shared.ts
+import { readFileSync } from "fs";
+function fileArg(kind, description) {
+  return {
+    file: payloadArg(
+      {
+        type: "string",
+        description: `${description} \u2014 run \`baker schema\` on this command for every field the payload takes`
+      },
+      () => describeOpPayload(metaDraftOpInputSchema, kind)
+    )
+  };
+}
+async function bareAccountId(args) {
+  return (await resolveAccountIdArg(args)).replace(/^act_/, "");
+}
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function refuseDeleteByUpdate(payload, group) {
+  if (payload.status === "DELETED") {
+    failWriteValidation(
+      `update does not delete \u2014 deleting is permanent. Use \`baker ads meta ${group} delete <id>\` if the user asked to delete; otherwise pause or archive.`
+    );
+  }
+}
+function loadJsonFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return {};
+  }
+  const inline = /^\s*\{/.test(path);
+  const source = inline ? "inline JSON" : path;
+  try {
+    const parsed = JSON.parse(inline ? path : readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation(`${source} must contain a JSON object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`${source} is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function mergePayload(file, flags) {
+  const merged = { ...file };
+  for (const [key, value] of Object.entries(flags)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function parseMoneyFlag(amount, currency, flag) {
+  if (amount === void 0 || amount === null || amount === "") {
+    return void 0;
+  }
+  if (currency === void 0 || currency === null || currency === "") {
+    return { amount: String(amount) };
+  }
+  if (typeof currency !== "string" || currency.length !== 3) {
+    failWriteValidation(`${flag} got an invalid --currency (expected a 3-letter code like USD)`);
+  }
+  return { amount: String(amount), currencyCode: currency.toUpperCase() };
+}
+function parseDateFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value);
+  if (/^\d{10,}$/.test(raw)) {
+    return Number(raw);
+  }
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    failWriteValidation(`${flag} must be an ISO date (2026-07-10) or epoch milliseconds`);
+  }
+  return parsed;
+}
+function listFlag(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return void 0;
+  }
+  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+function repeatedListFlag(rawArgs, flag, parsed) {
+  const items = repeatedValues(rawArgs, flag, parsed).flatMap((value) => value.split(",")).map((item) => item.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+function upper(value) {
+  return typeof value === "string" && value.length > 0 ? value.toUpperCase() : void 0;
+}
+function numberFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n)) {
+    failWriteValidation(`${flag} must be a number`);
+  }
+  return n;
+}
+function requireTarget(args, entity) {
+  const inverted = booleanWordPositionalError(args, entity);
+  if (inverted !== void 0) {
+    failWriteValidation(inverted);
+  }
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? args.ref ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} id as the positional argument`);
+  }
+  return target;
+}
+function preflightOp(raw) {
+  const preflight = metaDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    const fields = preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; "),
+        fields,
+        fix: payloadFix("meta-ads", metaDraftOpInputSchema, raw)
+      }
+    });
+    process.exit(1);
+  }
+  return preflight.data;
+}
+async function stageOp(raw, extraHints = []) {
+  const op = preflightOp(raw);
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/meta/draft/stage", { chatId, op });
+    const copyHints = await adCopyHints(op);
+    writeJsonEnvelope(withHints(response, [...copyHints, ...extraHints]));
+  } catch (err) {
+    handleMetaError(err);
+  }
+}
+async function stageOps(raws) {
+  const ops = raws.map(preflightOp);
+  const chatId = requireChatId();
+  const staged = [];
+  for (const op of ops) {
+    try {
+      const response = await apiPost("/api/ads/meta/draft/stage", { chatId, op });
+      staged.push(response.data);
+    } catch (err) {
+      if (staged.length > 0) {
+        process.stderr.write(`staged before the refusal: ${staged.map((entry) => entry.ref).join(", ")}
+`);
+      }
+      handleMetaError(err);
+    }
+  }
+  writeJsonEnvelope({ ok: true, data: staged });
+}
+async function stageStatusChange(input) {
+  await stageOp({
+    kind: input.kind,
+    accountId: input.accountId,
+    target: input.target,
+    payload: { status: input.status }
+  });
+}
+
+export {
+  fileArg,
+  bareAccountId,
+  failWriteValidation,
+  refuseDeleteByUpdate,
+  loadJsonFileArg,
+  mergePayload,
+  parseMoneyFlag,
+  parseDateFlag,
+  listFlag,
+  repeatedListFlag,
+  upper,
+  numberFlag,
+  requireTarget,
+  stageOp,
+  stageOps,
+  stageStatusChange
+};
+//# sourceMappingURL=chunk-EENYLJUN.js.map

package/dist/chunk-EJBLF2LI.js

@@ -0,0 +1,167 @@
+import {
+  parseRefExpr
+} from "./chunk-X3GWGFZP.js";
+import {
+  collectAssetRefLikes,
+  isPersistedAssetRef
+} from "./chunk-EL3TDR5S.js";
+
+// src/commands/canvas/run-record.ts
+import path from "path";
+var MAX_RUN_NODES = 200;
+var MAX_OUTPUTS_PER_NODE = 10;
+var MAX_FINAL_OUTPUTS = 10;
+var MAX_NODE_FACTS_CHARS = 4096;
+var MAX_CREATIVE_SLUG_LENGTH = 100;
+function creativeSlugFromCanvasPath(filePath) {
+  const normalized = filePath.split(path.sep).join("/");
+  const match = normalized.match(/(?:^|\/)src\/creatives\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\//);
+  const slug = match?.[1] ?? null;
+  return slug && slug.length <= MAX_CREATIVE_SLUG_LENGTH ? slug : null;
+}
+function finalOutputLabelsFromCanvas(parsed) {
+  const canvas = parsed;
+  const outputNodeId = canvas?.output?.node;
+  if (typeof outputNodeId !== "string" || !Array.isArray(canvas?.nodes)) return null;
+  const node = canvas.nodes.find((n) => n?.id === outputNodeId);
+  if (node?.type !== "collect") return null;
+  const explicit = node.params?.labels;
+  if (Array.isArray(explicit) && explicit.every((l) => typeof l === "string")) {
+    return { nodeId: outputNodeId, labels: explicit };
+  }
+  const images = node.inputs?.images;
+  if (!Array.isArray(images)) return null;
+  const labels = images.map((entry) => {
+    if (typeof entry !== "string") return void 0;
+    return parseRefExpr(entry)?.nodeId;
+  });
+  return { nodeId: outputNodeId, labels };
+}
+var OUTPUT_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
+function toRecordOutput(slot, value, label) {
+  const refs = collectAssetRefLikes(value);
+  const ref = refs.length === 1 ? refs[0] : null;
+  if (!ref || !isPersistedAssetRef(ref)) return null;
+  const kind = typeof ref.kind === "string" && OUTPUT_KINDS.has(ref.kind) ? ref.kind : null;
+  if (!kind) return null;
+  return {
+    slot,
+    label,
+    kind,
+    sha256: ref.sha256,
+    url: ref.url,
+    mime: ref.mime,
+    width: typeof ref.width === "number" ? ref.width : void 0,
+    height: typeof ref.height === "number" ? ref.height : void 0,
+    durationMs: typeof ref.duration_ms === "number" ? ref.duration_ms : void 0
+  };
+}
+function nodeOutputsToRecord(nodeOutputs, labels) {
+  const out = [];
+  for (const [slot, value] of Object.entries(nodeOutputs)) {
+    if (Array.isArray(value)) {
+      value.forEach((item, i) => {
+        const rec = toRecordOutput(`${slot}#${i}`, item, labels?.[i]);
+        if (rec) out.push(rec);
+      });
+    } else {
+      const rec = toRecordOutput(slot, value);
+      if (rec) out.push(rec);
+    }
+  }
+  return out.slice(0, MAX_OUTPUTS_PER_NODE);
+}
+function finalOutputsToRecord(output, labels) {
+  if (Array.isArray(output)) {
+    return output.map((item, i) => toRecordOutput(`final#${i}`, item, labels?.[i])).filter((rec2) => rec2 !== null).slice(0, MAX_FINAL_OUTPUTS);
+  }
+  const rec = toRecordOutput("final", output);
+  return rec ? [rec] : [];
+}
+function finalFiles(output, labels) {
+  const items = Array.isArray(output) ? output : [output];
+  const files = {};
+  items.forEach((item, i) => {
+    const ref = collectAssetRefLikes(item)[0];
+    if (ref && typeof ref.path === "string") files[labels?.[i] ?? `final#${i}`] = ref.path;
+  });
+  return files;
+}
+function withFacts(nodeOutputs) {
+  const facts = nodeOutputs.facts;
+  if (facts === void 0 || facts === null) return {};
+  const json = JSON.stringify(facts);
+  return json.length <= MAX_NODE_FACTS_CHARS ? { facts: json } : {};
+}
+function buildRunRecord(result, meta, plan, finalLabels) {
+  const nodes = result.node_runs.slice(0, MAX_RUN_NODES).map((run) => {
+    const planned = plan?.get(run.node_id);
+    return {
+      nodeId: run.node_id,
+      nodeType: run.node_type,
+      cached: run.cached,
+      credits: run.credits,
+      durationMs: run.duration_ms,
+      outputs: nodeOutputsToRecord(
+        result.outputs_by_node[run.node_id] ?? {},
+        run.node_id === finalLabels?.nodeId ? finalLabels.labels : void 0
+      ),
+      deps: planned?.deps,
+      status: plan ? "completed" : void 0,
+      paramsPreview: planned?.paramsPreview,
+      ...planned?.role !== void 0 ? { role: planned.role } : {},
+      ...withFacts(result.outputs_by_node[run.node_id] ?? {})
+    };
+  });
+  const finalOutputs = finalOutputsToRecord(result.output, finalLabels?.labels);
+  return {
+    runId: result.run_id,
+    ...meta,
+    status: "completed",
+    stats: {
+      totalNodes: result.stats.total_nodes,
+      cachedNodes: result.stats.cached_nodes,
+      totalCredits: result.stats.total_credits,
+      durationMs: result.stats.duration_ms
+    },
+    nodes,
+    finalOutputs: finalOutputs.length > 0 ? finalOutputs : void 0,
+    // Sent whenever the review RAN, empty list included. Sending it only when there
+    // were findings makes a clean render and an unreviewed one look identical in the
+    // record — which is the exact ambiguity this field was added to remove: proving a
+    // review had happened once meant re-running a cached canvas and reading raw JSON.
+    // Only the fields the backend keeps: a static review's typed fields (`kind`) stay in the CLI.
+    ...meta.review ? { review: meta.review.slice(0, 40).map(({ severity, what, scene }) => ({ severity, what, ...scene ? { scene } : {} })) } : {}
+  };
+}
+function buildInitialRunRecord(runId, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "running",
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+function buildFailedRunRecord(runId, errorMessage, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "failed",
+    errorMessage: errorMessage.slice(0, 2e3),
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+
+export {
+  creativeSlugFromCanvasPath,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord,
+  finalFiles,
+  withFacts,
+  buildRunRecord,
+  buildInitialRunRecord,
+  buildFailedRunRecord
+};
+//# sourceMappingURL=chunk-EJBLF2LI.js.map

package/dist/chunk-EJMPKO6V.js

@@ -0,0 +1,287 @@
+import {
+  failWriteValidation,
+  parseDateFlag,
+  parseMoneyFlag
+} from "./chunk-EENYLJUN.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-EJMPKO6V.js.map