@koda-sl/baker-cli 0.385.0-dev.ec7b0e42b → 0.385.0-dev.f7ef4c7e1

package/dist/chunk-ERSX3MKH.js

@@ -0,0 +1,34 @@
+// src/lib/repeatedFlags.ts
+function repeatedFlagValues(rawArgs, flag) {
+  const long = `--${flag}`;
+  const inline = `${long}=`;
+  const values = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--") break;
+    if (arg === long) {
+      const value = rawArgs[i + 1];
+      if (value !== void 0 && !value.startsWith("-")) {
+        values.push(value);
+        i++;
+      }
+    } else if (arg?.startsWith(inline)) {
+      values.push(arg.slice(inline.length));
+    }
+  }
+  return values;
+}
+function repeatedValues(rawArgs, flag, parsed) {
+  if (rawArgs !== void 0) {
+    const fromLine = repeatedFlagValues(rawArgs, flag);
+    if (fromLine.length > 0) return fromLine;
+  }
+  if (Array.isArray(parsed)) return parsed.filter((v) => typeof v === "string");
+  return typeof parsed === "string" && parsed.length > 0 ? [parsed] : [];
+}
+
+export {
+  repeatedFlagValues,
+  repeatedValues
+};
+//# sourceMappingURL=chunk-ERSX3MKH.js.map

package/dist/chunk-ERSX3MKH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/repeatedFlags.ts"],"sourcesContent":["/**\n * Every value a flag was given on the command line.\n *\n * citty declares no array arg type: it hands `util.parseArgs` its options\n * without `multiple: true`, so a repeated flag collapses to its LAST value.\n * `--param utm_source=linkedin --param utm_medium=paid` reaches `run` as the\n * single string `\"utm_medium=paid\"`, and code shaped like\n * `Array.isArray(raw) ? raw : [raw]` never takes its array branch.\n *\n * That is silent, and on a wholesale-replace write it is destructive: the\n * command reports success having staged one pair of the three it was given,\n * and publish then replaces the entity's whole parameter set with that one.\n * So every repeatable flag reads its values from `ctx.rawArgs` instead.\n *\n * Accepts both spellings (`--flag value` and `--flag=value`), stops at a bare\n * `--`, and ignores a trailing flag with no value — that is a malformed line,\n * not an empty value.\n */\nexport function repeatedFlagValues(rawArgs: readonly string[], flag: string): string[] {\n  const long = `--${flag}`;\n  const inline = `${long}=`;\n  const values: string[] = [];\n  for (let i = 0; i < rawArgs.length; i++) {\n    const arg = rawArgs[i];\n    if (arg === \"--\") break;\n    if (arg === long) {\n      const value = rawArgs[i + 1];\n      if (value !== undefined && !value.startsWith(\"-\")) {\n        values.push(value);\n        i++;\n      }\n    } else if (arg?.startsWith(inline)) {\n      values.push(arg.slice(inline.length));\n    }\n  }\n  return values;\n}\n\n/**\n * The values of a repeatable flag, preferring the command line over the parsed\n * arg. `rawArgs` is absent in unit tests that call a payload builder directly\n * with an already-collected array, so the parsed value stays the fallback.\n */\nexport function repeatedValues(rawArgs: readonly string[] | undefined, flag: string, parsed: unknown): string[] {\n  if (rawArgs !== undefined) {\n    const fromLine = repeatedFlagValues(rawArgs, flag);\n    if (fromLine.length > 0) return fromLine;\n  }\n  if (Array.isArray(parsed)) return parsed.filter((v): v is string => typeof v === \"string\");\n  return typeof parsed === \"string\" && parsed.length > 0 ? [parsed] : [];\n}\n"],"mappings":";AAkBO,SAAS,mBAAmB,SAA4B,MAAwB;AACrF,QAAM,OAAO,KAAK,IAAI;AACtB,QAAM,SAAS,GAAG,IAAI;AACtB,QAAM,SAAmB,CAAC;AAC1B,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,UAAM,MAAM,QAAQ,CAAC;AACrB,QAAI,QAAQ,KAAM;AAClB,QAAI,QAAQ,MAAM;AAChB,YAAM,QAAQ,QAAQ,IAAI,CAAC;AAC3B,UAAI,UAAU,UAAa,CAAC,MAAM,WAAW,GAAG,GAAG;AACjD,eAAO,KAAK,KAAK;AACjB;AAAA,MACF;AAAA,IACF,WAAW,KAAK,WAAW,MAAM,GAAG;AAClC,aAAO,KAAK,IAAI,MAAM,OAAO,MAAM,CAAC;AAAA,IACtC;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,eAAe,SAAwC,MAAc,QAA2B;AAC9G,MAAI,YAAY,QAAW;AACzB,UAAM,WAAW,mBAAmB,SAAS,IAAI;AACjD,QAAI,SAAS,SAAS,EAAG,QAAO;AAAA,EAClC;AACA,MAAI,MAAM,QAAQ,MAAM,EAAG,QAAO,OAAO,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ;AACzF,SAAO,OAAO,WAAW,YAAY,OAAO,SAAS,IAAI,CAAC,MAAM,IAAI,CAAC;AACvE;","names":[]}

package/dist/chunk-F7HRLPR5.js

@@ -0,0 +1,67 @@
+import {
+  parseXApiError
+} from "./chunk-M6UNISGO.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-EIGXX6KI.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-CUL3VB4L.js";
+
+// src/commands/ads/x/run-list.ts
+function buildCleanParams(opts) {
+  const out = {};
+  for (const [k, v] of Object.entries(opts.params)) {
+    if (v !== void 0 && v !== "") {
+      out[k] = v;
+    }
+  }
+  if (!opts.useCache) {
+    out["skip-cache"] = "true";
+  }
+  return out;
+}
+function emitFromCache(opts) {
+  if (!opts.useCache || opts.cacheTtlMs === void 0) return false;
+  const cached = cacheGet(opts.cacheCategory, opts.cacheKey);
+  if (!cached) return false;
+  writeAdsJson({ ok: true, data: cached.data, cached: true });
+  return true;
+}
+function emitData(opts, data) {
+  if (opts.format !== "json") {
+    writeAdsOutput(data, opts.format);
+    return;
+  }
+  writeAdsJson({ ok: true, data });
+}
+function emitError(opts, err) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, opts.accountId ?? "\u2014"));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+async function runListCommand(opts) {
+  if (emitFromCache(opts)) return;
+  const params = buildCleanParams(opts);
+  try {
+    const data = await apiGet(opts.path, params);
+    if (opts.useCache && opts.cacheTtlMs !== void 0) {
+      cacheSet(opts.cacheCategory, opts.cacheKey, data, opts.cacheTtlMs);
+    }
+    emitData(opts, data);
+  } catch (err) {
+    emitError(opts, err);
+  }
+}
+
+export {
+  runListCommand
+};
+//# sourceMappingURL=chunk-F7HRLPR5.js.map

package/dist/chunk-F7HRLPR5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/x/run-list.ts"],"sourcesContent":["import { ApiError, apiGet } from \"../../../client.ts\";\nimport { cacheGet, cacheSet } from \"../cache.ts\";\nimport { writeAdsJson, writeAdsOutput } from \"../output.ts\";\nimport { parseXApiError } from \"./error-parser.ts\";\n\ninterface ListParams {\n  path: string;\n  cacheCategory: string;\n  cacheKey: string;\n  cacheTtlMs?: number;\n  params: Record<string, string | undefined>;\n  format: string;\n  accountId?: string;\n  useCache: boolean;\n}\n\nfunction buildCleanParams(opts: ListParams): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const [k, v] of Object.entries(opts.params)) {\n    if (v !== undefined && v !== \"\") {\n      out[k] = v;\n    }\n  }\n  if (!opts.useCache) {\n    out[\"skip-cache\"] = \"true\";\n  }\n  return out;\n}\n\nfunction emitFromCache(opts: ListParams): boolean {\n  if (!opts.useCache || opts.cacheTtlMs === undefined) return false;\n  const cached = cacheGet<unknown[]>(opts.cacheCategory, opts.cacheKey);\n  if (!cached) return false;\n  writeAdsJson({ ok: true, data: cached.data, cached: true });\n  return true;\n}\n\nfunction emitData(opts: ListParams, data: unknown[]): void {\n  if (opts.format !== \"json\") {\n    writeAdsOutput(data as Array<Record<string, unknown>>, opts.format);\n    return;\n  }\n  writeAdsJson({ ok: true, data });\n}\n\nfunction emitError(opts: ListParams, err: unknown): never {\n  if (err instanceof ApiError) {\n    writeAdsJson(parseXApiError(err.message, opts.accountId ?? \"—\"));\n    process.exit(1);\n  }\n  writeAdsJson({ ok: false, error: { code: \"NETWORK_ERROR\", message: \"Unexpected error\" } });\n  process.exit(1);\n}\n\n/**\n * Shared GET-list flow: cache check → request → cache set → format-aware output.\n * Centralizing this keeps each CLI command file under Biome's complexity budget.\n */\nexport async function runListCommand(opts: ListParams): Promise<void> {\n  if (emitFromCache(opts)) return;\n  const params = buildCleanParams(opts);\n  try {\n    const data = await apiGet<unknown[]>(opts.path, params);\n    if (opts.useCache && opts.cacheTtlMs !== undefined) {\n      cacheSet(opts.cacheCategory, opts.cacheKey, data, opts.cacheTtlMs);\n    }\n    emitData(opts, data);\n  } catch (err) {\n    emitError(opts, err);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,SAAS,iBAAiB,MAA0C;AAClE,QAAM,MAA8B,CAAC;AACrC,aAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,KAAK,MAAM,GAAG;AAChD,QAAI,MAAM,UAAa,MAAM,IAAI;AAC/B,UAAI,CAAC,IAAI;AAAA,IACX;AAAA,EACF;AACA,MAAI,CAAC,KAAK,UAAU;AAClB,QAAI,YAAY,IAAI;AAAA,EACtB;AACA,SAAO;AACT;AAEA,SAAS,cAAc,MAA2B;AAChD,MAAI,CAAC,KAAK,YAAY,KAAK,eAAe,OAAW,QAAO;AAC5D,QAAM,SAAS,SAAoB,KAAK,eAAe,KAAK,QAAQ;AACpE,MAAI,CAAC,OAAQ,QAAO;AACpB,eAAa,EAAE,IAAI,MAAM,MAAM,OAAO,MAAM,QAAQ,KAAK,CAAC;AAC1D,SAAO;AACT;AAEA,SAAS,SAAS,MAAkB,MAAuB;AACzD,MAAI,KAAK,WAAW,QAAQ;AAC1B,mBAAe,MAAwC,KAAK,MAAM;AAClE;AAAA,EACF;AACA,eAAa,EAAE,IAAI,MAAM,KAAK,CAAC;AACjC;AAEA,SAAS,UAAU,MAAkB,KAAqB;AACxD,MAAI,eAAe,UAAU;AAC3B,iBAAa,eAAe,IAAI,SAAS,KAAK,aAAa,QAAG,CAAC;AAC/D,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,eAAa,EAAE,IAAI,OAAO,OAAO,EAAE,MAAM,iBAAiB,SAAS,mBAAmB,EAAE,CAAC;AACzF,UAAQ,KAAK,CAAC;AAChB;AAMA,eAAsB,eAAe,MAAiC;AACpE,MAAI,cAAc,IAAI,EAAG;AACzB,QAAM,SAAS,iBAAiB,IAAI;AACpC,MAAI;AACF,UAAM,OAAO,MAAM,OAAkB,KAAK,MAAM,MAAM;AACtD,QAAI,KAAK,YAAY,KAAK,eAAe,QAAW;AAClD,eAAS,KAAK,eAAe,KAAK,UAAU,MAAM,KAAK,UAAU;AAAA,IACnE;AACA,aAAS,MAAM,IAAI;AAAA,EACrB,SAAS,KAAK;AACZ,cAAU,MAAM,GAAG;AAAA,EACrB;AACF;","names":[]}

package/dist/chunk-FEG6MN4H.js

@@ -0,0 +1,84 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-TNOSX3PJ.js";
+
+// src/commands/canvas/unbilled-spend.ts
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var DIR = "unbilled-spend";
+var Held = z.array(
+  z.object({ model: z.string(), inputTokens: z.number(), outputTokens: z.number(), costUsd: z.number() })
+);
+async function holdUnbilledSpend(cacheDir, usage) {
+  if (usage.length === 0) return;
+  const dir = path.join(cacheDir, DIR);
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, `${Date.now()}-${randomUUID()}.json`), JSON.stringify(usage), "utf8");
+}
+async function holdWorkspaceSpend(usage) {
+  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+  await holdUnbilledSpend(path.join(root, "canvas", ".cache"), usage).catch(() => {
+  });
+}
+async function takeUnbilledSpend(cacheDir) {
+  const dir = path.join(cacheDir, DIR);
+  const files = await readdir(dir).catch(() => []);
+  const byModel = /* @__PURE__ */ new Map();
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    const claimed = path.join(dir, `${file}.${randomUUID()}.taken`);
+    try {
+      await rename(path.join(dir, file), claimed);
+    } catch {
+      continue;
+    }
+    const parsed = Held.safeParse(await readFile(claimed, "utf8").then(JSON.parse, () => null).catch(() => null));
+    await unlink(claimed).catch(() => {
+    });
+    for (const call of parsed.success ? parsed.data : []) {
+      const sum = byModel.get(call.model);
+      byModel.set(
+        call.model,
+        sum ? {
+          model: call.model,
+          inputTokens: sum.inputTokens + call.inputTokens,
+          outputTokens: sum.outputTokens + call.outputTokens,
+          costUsd: sum.costUsd + call.costUsd
+        } : { ...call }
+      );
+    }
+  }
+  return [...byModel.values()];
+}
+async function sendBillingSpend(cacheDir, usage, send) {
+  try {
+    await send();
+    return null;
+  } catch (e) {
+    await holdUnbilledSpend(cacheDir, usage).catch(() => {
+    });
+    return e instanceof Error ? e.message : String(e);
+  }
+}
+function holdWhenSettled(cacheDir, spendOf) {
+  const pending = [];
+  return {
+    settled: (run, outputs) => {
+      pending.push(holdUnbilledSpend(cacheDir, spendOf(run, outputs)).catch(() => {
+      }));
+    },
+    drained: async () => {
+      await Promise.all(pending);
+    }
+  };
+}
+
+export {
+  holdUnbilledSpend,
+  holdWorkspaceSpend,
+  takeUnbilledSpend,
+  sendBillingSpend,
+  holdWhenSettled
+};
+//# sourceMappingURL=chunk-FEG6MN4H.js.map

package/dist/chunk-FEG6MN4H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/unbilled-spend.ts"],"sourcesContent":["/**\n * Gateway spend the CLI made with no run record to carry it: the viewer check run on its\n * own (`baker canvas viewer-check`) or one that refused the render before any run existed.\n *\n * The run record's `reviewUsage` is how a call made in the Runtime reaches the credits\n * ledger (`POST /api/canvas/runs` bills it once, when the terminal record is accepted). So\n * the spend waits here, in the workspace's canvas cache, and the next run record of this\n * workspace takes it. One file per hold and a rename to claim it: two processes never take\n * the same call, and a hold never overwrites another.\n */\nimport { randomUUID } from \"node:crypto\";\nimport { mkdir, readdir, readFile, rename, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { z } from \"zod\";\nimport type { NodeRunRecord } from \"../../engine/engine/executor.ts\";\nimport type { ReviewUsage } from \"../../engine/nodes/local/lib/render-review.ts\";\nimport { findWorkspaceRoot } from \"./normalize-paths.ts\";\n\nconst DIR = \"unbilled-spend\";\n\nconst Held = z.array(\n  z.object({ model: z.string(), inputTokens: z.number(), outputTokens: z.number(), costUsd: z.number() }),\n);\n\n/** Keep `usage` for the next run record of this workspace; nothing is written when it is empty. */\nexport async function holdUnbilledSpend(cacheDir: string, usage: readonly ReviewUsage[]): Promise<void> {\n  if (usage.length === 0) return;\n  const dir = path.join(cacheDir, DIR);\n  await mkdir(dir, { recursive: true });\n  await writeFile(path.join(dir, `${Date.now()}-${randomUUID()}.json`), JSON.stringify(usage), \"utf8\");\n}\n\n/**\n * One call made by a command with no canvas of its own (`baker actions create`, a feedback note,\n * a CRM file check), held in the workspace the command ran in. Never throws: a lost hold is a\n * call Baker absorbs, never a failed command.\n */\nexport async function holdWorkspaceSpend(usage: readonly ReviewUsage[]): Promise<void> {\n  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();\n  await holdUnbilledSpend(path.join(root, \"canvas\", \".cache\"), usage).catch(() => {});\n}\n\n/** Every held call, claimed and removed, summed per model (one record entry each). */\nexport async function takeUnbilledSpend(cacheDir: string): Promise<ReviewUsage[]> {\n  const dir = path.join(cacheDir, DIR);\n  const files = await readdir(dir).catch(() => [] as string[]);\n  const byModel = new Map<string, ReviewUsage>();\n  for (const file of files.filter((f) => f.endsWith(\".json\"))) {\n    const claimed = path.join(dir, `${file}.${randomUUID()}.taken`);\n    try {\n      await rename(path.join(dir, file), claimed);\n    } catch {\n      continue;\n    }\n    const parsed = Held.safeParse(await readFile(claimed, \"utf8\").then(JSON.parse, () => null).catch(() => null));\n    await unlink(claimed).catch(() => {});\n    for (const call of parsed.success ? parsed.data : []) {\n      const sum = byModel.get(call.model);\n      byModel.set(\n        call.model,\n        sum\n          ? {\n              model: call.model,\n              inputTokens: sum.inputTokens + call.inputTokens,\n              outputTokens: sum.outputTokens + call.outputTokens,\n              costUsd: sum.costUsd + call.costUsd,\n            }\n          : { ...call },\n      );\n    }\n  }\n  return [...byModel.values()];\n}\n\n/**\n * Send the record that carries `usage`: null when it landed, else why not. When it never does, the\n * spend is held again for the next one; the failure is reported, never thrown, because a\n * record that did not land must not turn a finished render into a failed one.\n */\nexport async function sendBillingSpend(\n  cacheDir: string,\n  usage: readonly ReviewUsage[],\n  send: () => Promise<void>,\n): Promise<string | null> {\n  try {\n    await send();\n    return null;\n  } catch (e) {\n    await holdUnbilledSpend(cacheDir, usage).catch(() => {});\n    return e instanceof Error ? e.message : String(e);\n  }\n}\n\n/**\n * Hold what a node's own gateway calls cost the moment it settles, so the spend survives the\n * run failing or being stopped after it: the resumed run takes that node from the cache and\n * bills nothing for it. `spendOf` returns [] for a cached node or one that calls nothing.\n */\nexport function holdWhenSettled(\n  cacheDir: string,\n  spendOf: (run: NodeRunRecord, outputs: Record<string, unknown>) => readonly ReviewUsage[],\n): { settled: (run: NodeRunRecord, outputs: Record<string, unknown>) => void; drained: () => Promise<void> } {\n  const pending: Promise<void>[] = [];\n  return {\n    settled: (run, outputs) => {\n      pending.push(holdUnbilledSpend(cacheDir, spendOf(run, outputs)).catch(() => {}));\n    },\n    drained: async () => {\n      await Promise.all(pending);\n    },\n  };\n}\n"],"mappings":";;;;;AAUA,SAAS,kBAAkB;AAC3B,SAAS,OAAO,SAAS,UAAU,QAAQ,QAAQ,iBAAiB;AACpE,OAAO,UAAU;AACjB,SAAS,SAAS;AAKlB,IAAM,MAAM;AAEZ,IAAM,OAAO,EAAE;AAAA,EACb,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,aAAa,EAAE,OAAO,GAAG,cAAc,EAAE,OAAO,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC;AACxG;AAGA,eAAsB,kBAAkB,UAAkB,OAA8C;AACtG,MAAI,MAAM,WAAW,EAAG;AACxB,QAAM,MAAM,KAAK,KAAK,UAAU,GAAG;AACnC,QAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC,QAAM,UAAU,KAAK,KAAK,KAAK,GAAG,KAAK,IAAI,CAAC,IAAI,WAAW,CAAC,OAAO,GAAG,KAAK,UAAU,KAAK,GAAG,MAAM;AACrG;AAOA,eAAsB,mBAAmB,OAA8C;AACrF,QAAM,OAAO,kBAAkB,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI;AAC7D,QAAM,kBAAkB,KAAK,KAAK,MAAM,UAAU,QAAQ,GAAG,KAAK,EAAE,MAAM,MAAM;AAAA,EAAC,CAAC;AACpF;AAGA,eAAsB,kBAAkB,UAA0C;AAChF,QAAM,MAAM,KAAK,KAAK,UAAU,GAAG;AACnC,QAAM,QAAQ,MAAM,QAAQ,GAAG,EAAE,MAAM,MAAM,CAAC,CAAa;AAC3D,QAAM,UAAU,oBAAI,IAAyB;AAC7C,aAAW,QAAQ,MAAM,OAAO,CAAC,MAAM,EAAE,SAAS,OAAO,CAAC,GAAG;AAC3D,UAAM,UAAU,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,WAAW,CAAC,QAAQ;AAC9D,QAAI;AACF,YAAM,OAAO,KAAK,KAAK,KAAK,IAAI,GAAG,OAAO;AAAA,IAC5C,QAAQ;AACN;AAAA,IACF;AACA,UAAM,SAAS,KAAK,UAAU,MAAM,SAAS,SAAS,MAAM,EAAE,KAAK,KAAK,OAAO,MAAM,IAAI,EAAE,MAAM,MAAM,IAAI,CAAC;AAC5G,UAAM,OAAO,OAAO,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AACpC,eAAW,QAAQ,OAAO,UAAU,OAAO,OAAO,CAAC,GAAG;AACpD,YAAM,MAAM,QAAQ,IAAI,KAAK,KAAK;AAClC,cAAQ;AAAA,QACN,KAAK;AAAA,QACL,MACI;AAAA,UACE,OAAO,KAAK;AAAA,UACZ,aAAa,IAAI,cAAc,KAAK;AAAA,UACpC,cAAc,IAAI,eAAe,KAAK;AAAA,UACtC,SAAS,IAAI,UAAU,KAAK;AAAA,QAC9B,IACA,EAAE,GAAG,KAAK;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AACA,SAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;AAC7B;AAOA,eAAsB,iBACpB,UACA,OACA,MACwB;AACxB,MAAI;AACF,UAAM,KAAK;AACX,WAAO;AAAA,EACT,SAAS,GAAG;AACV,UAAM,kBAAkB,UAAU,KAAK,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AACvD,WAAO,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;AAAA,EAClD;AACF;AAOO,SAAS,gBACd,UACA,SAC2G;AAC3G,QAAM,UAA2B,CAAC;AAClC,SAAO;AAAA,IACL,SAAS,CAAC,KAAK,YAAY;AACzB,cAAQ,KAAK,kBAAkB,UAAU,QAAQ,KAAK,OAAO,CAAC,EAAE,MAAM,MAAM;AAAA,MAAC,CAAC,CAAC;AAAA,IACjF;AAAA,IACA,SAAS,YAAY;AACnB,YAAM,QAAQ,IAAI,OAAO;AAAA,IAC3B;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-FKOECEVC.js

@@ -0,0 +1,126 @@
+// 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"],
+  linkedin: ["linkedin.com", "lnkd.in"],
+  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 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 "";
+  }
+}
+
+export {
+  MAX_VIDEO_INGEST_BYTES,
+  MAX_VIDEO_INGEST_SECONDS,
+  refuseByDuration,
+  downloadTimeoutMs,
+  isDirectMediaUrl,
+  resolveIngestSource,
+  isToolingOrBlockFailure,
+  isDrmProtected,
+  isRegionBlocked,
+  worthDownloadingInstead,
+  directDedupeKey
+};
+//# sourceMappingURL=chunk-FKOECEVC.js.map

package/dist/chunk-FKOECEVC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/videos/videoPlatforms.ts","../src/commands/videos/ingestUrl.ts"],"sourcesContent":["/**\n * Which platform a video link came from.\n *\n * This exists for provenance, not for capability. The downloader already reaches\n * far more sites than are named here, so a platform missing from this table\n * still ingests — it is simply recorded as `url`. What the table buys is the\n * ability to answer \"where did this clip come from\" later: a competitor's TikTok,\n * a supplier's Vimeo and the client's own YouTube are different things to a\n * marketer, and collapsing all three into \"url\" throws that away at the only\n * moment it is knowable.\n *\n * Kept deliberately small. Naming every site the downloader supports would be a\n * list nobody can maintain and would still be missing the next one; these are the\n * platforms whose provenance actually changes how a clip gets used.\n */\n\n/** Registrable domains per platform. Subdomains match; lookalikes must not. */\nconst PLATFORM_DOMAINS = {\n  youtube: [\"youtube.com\", \"youtu.be\"],\n  instagram: [\"instagram.com\", \"ddinstagram.com\"],\n  tiktok: [\"tiktok.com\"],\n  twitter: [\"twitter.com\", \"x.com\", \"vxtwitter.com\", \"fixvx.com\"],\n  facebook: [\"facebook.com\", \"fb.watch\", \"fb.com\"],\n  linkedin: [\"linkedin.com\", \"lnkd.in\"],\n  reddit: [\"reddit.com\", \"redd.it\"],\n  vimeo: [\"vimeo.com\"],\n  dailymotion: [\"dailymotion.com\", \"dai.ly\"],\n  twitch: [\"twitch.tv\"],\n  bluesky: [\"bsky.app\"],\n  bilibili: [\"bilibili.com\", \"bilibili.tv\", \"b23.tv\"],\n  vk: [\"vk.com\", \"vk.ru\", \"vkvideo.ru\"],\n  ok: [\"ok.ru\"],\n  pinterest: [\"pinterest.com\", \"pin.it\"],\n  tumblr: [\"tumblr.com\"],\n  snapchat: [\"snapchat.com\"],\n  loom: [\"loom.com\"],\n  streamable: [\"streamable.com\"],\n  newgrounds: [\"newgrounds.com\"],\n  rutube: [\"rutube.ru\"],\n} as const satisfies Record<string, readonly string[]>;\n\nexport type VideoPlatform = keyof typeof PLATFORM_DOMAINS;\n\n/** Every platform this can name; `platformFromUrl` returns one of these or `url`. */\nexport const VIDEO_PLATFORMS = Object.keys(PLATFORM_DOMAINS) as readonly VideoPlatform[];\n\n/**\n * The platform a URL belongs to, or `url` when it is not one we name.\n *\n * Matching is on the host, anchored at a dot boundary — never `includes`. That\n * is the whole security property of this function: `youtube.com.evil.test` and\n * `notyoutube.com` are attacker-controlled hosts that would otherwise inherit\n * YouTube's identity, and provenance that can be spoofed is worse than none,\n * because it is trusted.\n *\n * Pinterest is a deliberate omission from the country-mirror handling: cobalt\n * collapses `pinterest.co.uk` and friends, and doing the same here would mean\n * carrying a list of every ccTLD a platform has ever used. Those links resolve\n * as `url` and still ingest.\n */\nexport function platformFromUrl(rawUrl: string): VideoPlatform | \"url\" {\n  let host: string;\n  try {\n    host = new URL(rawUrl).hostname.toLowerCase();\n  } catch {\n    return \"url\";\n  }\n\n  for (const [platform, domains] of Object.entries(PLATFORM_DOMAINS)) {\n    if (domains.some((domain) => host === domain || host.endsWith(`.${domain}`))) {\n      return platform as VideoPlatform;\n    }\n  }\n  return \"url\";\n}\n","import { platformFromUrl } from \"./videoPlatforms.ts\";\n/**\n * URL classification for `baker videos ingest`. Pure so the routing decision —\n * hand the URL to Baker, or download it here first — is testable without a\n * network, a sandbox, or yt-dlp installed.\n */\n\n/**\n * Ceiling on the download path only. The direct path has no equivalent: Mux\n * fetches the file itself, so nothing is held in the Runtime's memory or disk.\n *\n * This was 2 GB, and it was never really a policy — it was a memory limit\n * wearing a policy's clothes. The upload read the whole file into a Buffer and\n * then copied it again into a `Uint8Array` (measured: that constructor does not\n * alias), so peak RAM was twice the file and an 8 GB Runtime would be OOM-killed\n * before the check ever fired. The file now streams from disk\n * (`lib/streamUpload.ts`), peak memory is one chunk regardless of length, and\n * this bounds the Runtime's *disk* — the last resource a download still spends\n * in proportion to how long the video is.\n *\n * The gate that does the real work is `refuseByDuration`, below: it turns away a\n * too-long video from its metadata, before a single byte is fetched.\n */\nexport const MAX_VIDEO_INGEST_BYTES = 16 * 1024 * 1024 * 1024;\n\n/** The longest video we will pull down, in seconds. */\nexport const MAX_VIDEO_INGEST_SECONDS = 3 * 60 * 60;\n\n/**\n * Whether a video is too long to ingest, phrased for whoever pasted the link.\n *\n * Duration rather than bytes, because duration is knowable *before* downloading\n * and a byte count is not: a watch page carries no `content-length`, an adaptive\n * stream has one per segment, and the merged file does not exist until it has\n * been muxed. So a byte cap can only be enforced after paying for the very\n * download it was supposed to avoid, while a duration cap costs one metadata\n * probe.\n *\n * An unknown duration is accepted, not refused. A live stream, or a site that\n * publishes no metadata, reports nothing — and treating silence as \"too long\"\n * would turn a missing field into a blocked ingest. The byte ceiling still\n * catches those on the way out.\n */\nexport function refuseByDuration(seconds: number | undefined, maxSeconds: number): string | null {\n  if (seconds === undefined || seconds <= maxSeconds) return null;\n  return `That video is ${(seconds / 3600).toFixed(1)} hours long — the limit is ${Math.round(maxSeconds / 3600)} hours.`;\n}\n\n/** Floor, and what an unknown duration gets: enough for any ordinary clip. */\nconst DOWNLOAD_TIMEOUT_FLOOR_MS = 10 * 60 * 1000;\n/**\n * Ceiling, and the binding constraint in practice.\n *\n * Set by what a person waiting in a chat will tolerate, not by what a download\n * might need: the turn is blocked for this whole time, and a chat that appears\n * frozen for three quarters of an hour is a worse outcome than a clip that did\n * not import. Fifteen minutes covers any ordinary clip even from a slow CDN,\n * and a video that cannot make it says so and points at `upload`.\n */\nconst DOWNLOAD_TIMEOUT_CEILING_MS = 15 * 60 * 1000;\n\n/**\n * How long a download may take, derived from how long the video is.\n *\n * These two numbers have to be related or they quietly contradict each other,\n * which is exactly what happened: the duration gate accepted up to three hours\n * while every download got a flat ten-minute window, so a 33-minute VK video —\n * served slowly, still transferring at 137 MB when the clock ran out — was\n * accepted by one rule and made impossible by another. It surfaced as\n * \"Unexpected error\", because a timeout throws a plain `Error` that the caller\n * discarded.\n *\n * Twice real-time is the budget: generous for a CDN serving faster than\n * playback, and still finite for one that is not. The ceiling matters more than\n * the ratio — without it a three-hour video would license a six-hour download.\n */\nexport function downloadTimeoutMs(seconds: number | undefined): number {\n  if (seconds === undefined) return DOWNLOAD_TIMEOUT_FLOOR_MS;\n  const scaled = seconds * 2 * 1000;\n  return Math.min(Math.max(scaled, DOWNLOAD_TIMEOUT_FLOOR_MS), DOWNLOAD_TIMEOUT_CEILING_MS);\n}\n\nconst DIRECT_MEDIA_EXTENSIONS = [\".mp4\", \".mov\", \".webm\", \".m4v\", \".mkv\", \".avi\"] as const;\n\n/**\n * True when the URL's path ends in a media extension, which is the signal that\n * Mux can pull it directly. Deliberately conservative: a false negative only\n * costs an unnecessary download, while a false positive hands Mux a web page.\n */\nexport function isDirectMediaUrl(rawUrl: string): boolean {\n  const pathname = safePathname(rawUrl);\n  return DIRECT_MEDIA_EXTENSIONS.some((ext) => pathname.endsWith(ext));\n}\n\n/** Explicit `--source` always wins; otherwise infer provenance from the host. */\nexport function resolveIngestSource(explicit: string | undefined, rawUrl: string): string {\n  if (explicit) return explicit;\n  return platformFromUrl(rawUrl);\n}\n\n/**\n * Signatures of \"the site wouldn't hand over the video\", as opposed to \"this\n * link is private or gone\".\n *\n * They matter because the remediation is opposite. These all mean the downloader\n * could not read the page — nearly always because it has aged out against a site\n * that changed (YouTube rewrites its player every few weeks) or because the\n * request was blocked. Retrying is useless and the user's link is fine, so\n * telling them to check whether their public video is \"private\" sends them after\n * a problem that isn't theirs.\n */\nconst TOOLING_OR_BLOCK_SIGNATURES = [\n  \"requested format is not available\",\n  \"only images are available\",\n  \"nsig\",\n  \"sign in to confirm\", // bot check — distinct from \"Private video. Sign in if…\"\n  \"unable to download api page\",\n  \"http error 403\",\n  // yt-dlp's own \"the site changed under me\" signature. It prints a GitHub issue\n  // link whenever a page parsed nothing like the shape the extractor expects —\n  // which is precisely a downloader that has aged out, not a bad link. Observed\n  // live on TikTok, which probed fine and then broke ninety minutes later from\n  // the same machine, identically through direct, datacenter and residential\n  // exits. Without this it fell through to \"check the link is public\", sending\n  // the reader to inspect a video that was never the problem.\n  \"please report this issue\",\n] as const;\n\nexport function isToolingOrBlockFailure(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  return TOOLING_OR_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n\n/**\n * Failures a *different country* could plausibly open — the only ones where\n * retrying with `--country` is worth suggesting.\n *\n * Deliberately narrow, and it is the narrowness that matters. Every rung of the\n * ladder already tries a different IP, so \"we were refused\" is not evidence that\n * geography was the reason; it is only evidence that geography *might* be. These\n * phrases are the ones where the site itself named the country.\n *\n * TikTok is the worked counter-example and the reason this is not a loose match\n * on \"blocked\": it answers with \"Your IP address is blocked from accessing this\n * post\", which reads exactly like a geo problem. Measured across six exits in\n * four countries — Spain direct, Spain datacenter, US, DE, SG, BR — that post\n * failed identically from all of them, while a different post succeeded from the\n * plain direct IP. Treating that string as regional would sell the agent a retry\n * that cannot work, once per country it thinks to try.\n */\nconst REGION_BLOCK_SIGNATURES = [\n  \"in your country\",\n  \"geo-restricted\",\n  \"geo restricted\",\n  \"not available from your location\",\n  \"blocked in your country\",\n] as const;\n\n/**\n * The video's own encryption refusing us — a hard stop, not a hurdle.\n *\n * Kept separate from every other failure because it is the only one where the\n * honest answer is \"no, and no amount of retrying, signing in or changing\n * country will alter that\". Removing DRM is a different act from downloading\n * something published openly, so this never suggests a workaround.\n *\n * Checked *before* the tooling signatures, because a DRM video also emits\n * \"Requested format is not available\" as its second line — and that phrase is\n * read as a stale downloader, which would file a permanent property of the video\n * as a bug in our tooling. Measured: `--check-formats`, the remedy yt-dlp's own\n * message suggests, does not help when the audio track is the encrypted part.\n */\nexport function isDrmProtected(detail: string): boolean {\n  return detail.toLowerCase().includes(\"drm protected\");\n}\n\nexport function isRegionBlocked(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  return REGION_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n\n/**\n * Whether a failed direct ingest is worth retrying by downloading the file\n * ourselves.\n *\n * The subtlety that makes this necessary: the download route finishes by posting\n * to the *same* endpoint, with the same API key and the same `source`. So a\n * failure about the request rather than about the URL is guaranteed to fail\n * again identically, except now after pulling the whole video down first.\n *\n * An allow-list of one, and it has to be, because the codes here are the CLI's\n * (`mapHttpError`), not the backend's. That distinction was previously missed:\n * this listed backend names, so `apiError(\"BAD_REQUEST\")` — the code the route\n * raises when Mux refuses the source, and the only case this exists for —\n * arrived as `VALIDATION_ERROR` and was refused, while a backend 500 arrived as\n * `INTERNAL_ERROR`, matched nothing, and downloaded a whole video to replay the\n * identical failing request. Naming the outcome we want, rather than the ones we\n * don't, means a code nobody anticipated costs a missed retry instead of a\n * wasted download.\n *\n * `VALIDATION_ERROR` is unambiguous *here* only because the request body is zod\n * validated client-side before it is ever sent, so a 400 from this route is not\n * a malformed request — it is Baker saying it could not fetch that URL.\n */\nexport function worthDownloadingInstead(errorCode: string): boolean {\n  return errorCode === \"VALIDATION_ERROR\";\n}\n\n/**\n * The dedupe key for a URL handed straight to Baker.\n *\n * The direct path never probes — that is the whole point of it — so there is no\n * provider id to key on and the URL is the only identifier available. That is\n * the same position the download path's *generic* extractor branch is in, and it\n * resolves it the same way, so a link filed directly and the same link filed via\n * the download fallback agree on one row instead of producing two.\n *\n * Keyed on the full URL rather than the filename: two unrelated clips are very\n * often both called `demo.mp4`, and a collision silently returns the wrong video\n * under a successful-looking response, which is far worse than a missed dedupe.\n * A signed URL carrying an expiring token simply never dedupes, which is the\n * harmless direction to fail in.\n */\nexport function directDedupeKey(source: string, rawUrl: string): string {\n  return `${source}:${rawUrl}`;\n}\n\nfunction safePathname(rawUrl: string): string {\n  try {\n    return new URL(rawUrl).pathname.toLowerCase();\n  } catch {\n    return \"\";\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-FMGW2NZI.js

@@ -0,0 +1,106 @@
+import {
+  cacheGet,
+  cacheSet,
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-EIGXX6KI.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-CUL3VB4L.js";
+import {
+  getEnv
+} from "./chunk-I4FTS5EE.js";
+
+// src/commands/ads/x/output.ts
+var ACCOUNTS_CACHE_TTL_MS = 60 * 60 * 1e3;
+var NO_X_ACCOUNTS_EXPLANATION = "The X Ads connection is live, but X lists no ads accounts for it. That is usually an account X has not activated for advertising yet \u2014 most often one with no billing set up. It does not mean the connection failed, and reconnecting will not change it. An account X omits here still works everywhere else: take its id from the ads.x.com URL (ads.x.com/manager/<id>/\u2026) and pass --account-id <id>, or set BAKER_X_ADS_ACCOUNT_ID.";
+async function fetchXAccounts(useCache) {
+  if (useCache) {
+    const cached = cacheGet("x-accounts", "list");
+    if (cached) return cached.data;
+  }
+  const params = !useCache ? { "skip-cache": "true" } : void 0;
+  const data = await apiGet("/api/ads/x/accounts", params);
+  if (useCache) {
+    cacheSet("x-accounts", "list", data, ACCOUNTS_CACHE_TTL_MS);
+  }
+  return data;
+}
+async function resolveXAccountId(args) {
+  const fromArgs = args["account-id"];
+  const accountId = fromArgs || getEnv().BAKER_X_ADS_ACCOUNT_ID;
+  if (accountId) {
+    if (!/^[a-z0-9]+$/.test(accountId)) {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "INVALID_ACCOUNT_ID",
+          message: "X Ads account ID must be a base36 string (lowercase letters and digits). Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID."
+        }
+      });
+      process.exit(1);
+    }
+    return accountId;
+  }
+  const useCache = !args["no-cache"];
+  try {
+    const accounts = await fetchXAccounts(useCache);
+    const [single] = accounts;
+    if (accounts.length === 1 && single) {
+      process.stderr.write(`Using account "${single.name}" (${single.id})
+`);
+      return single.id;
+    }
+    if (accounts.length === 0) {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "INVALID_ACCOUNT_ID",
+          message: NO_X_ACCOUNTS_EXPLANATION,
+          fix: { action: "reject", explanation: NO_X_ACCOUNTS_EXPLANATION },
+          retryable: false
+        }
+      });
+      process.exit(1);
+    }
+    const list = accounts.map((a) => `  ${a.id}  ${a.name}`).join("\n");
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MULTIPLE_ACCOUNTS",
+        message: `Multiple X Ads accounts found. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID:
+${list}`
+      }
+    });
+    process.exit(1);
+  } catch (err) {
+    if (err instanceof ApiError && needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("x_ads", err.message);
+    }
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: "Could not auto-detect account. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID."
+      }
+    });
+    process.exit(1);
+  }
+}
+async function resolveXAccountTimezone(accountId, args) {
+  try {
+    const accounts = await fetchXAccounts(!args["no-cache"]);
+    return accounts.find((a) => a.id === accountId)?.timezone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+export {
+  NO_X_ACCOUNTS_EXPLANATION,
+  resolveXAccountId,
+  resolveXAccountTimezone
+};
+//# sourceMappingURL=chunk-FMGW2NZI.js.map

package/dist/chunk-FMGW2NZI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/x/output.ts"],"sourcesContent":["import { ApiError, apiGet } from \"../../../client.ts\";\nimport { getEnv } from \"../../../env.ts\";\nimport { handleConnectionError, needsConnectionFix } from \"../../../error-handler.ts\";\nimport { cacheGet, cacheSet } from \"../cache.ts\";\nimport { writeAdsJson } from \"../output.ts\";\n\nexport interface XAccountInfo {\n  id: string;\n  name: string;\n  approval_status?: string;\n  timezone?: string;\n  currency?: string;\n}\n\nconst ACCOUNTS_CACHE_TTL_MS = 60 * 60 * 1000;\n\n/**\n * X serves `/accounts` from its own idea of an active advertiser account, and an account it\n * leaves out of that list still answers every child endpoint — campaigns, media, funding and\n * the rest all work when the id is named. So an empty list is a discovery problem, never a\n * broken grant, and telling the user to reconnect sends them round a loop that cannot help.\n */\nexport const NO_X_ACCOUNTS_EXPLANATION =\n  \"The X Ads connection is live, but X lists no ads accounts for it. That is usually an account \" +\n  \"X has not activated for advertising yet — most often one with no billing set up. It does not \" +\n  \"mean the connection failed, and reconnecting will not change it. An account X omits here still \" +\n  \"works everywhere else: take its id from the ads.x.com URL (ads.x.com/manager/<id>/…) and pass \" +\n  \"--account-id <id>, or set BAKER_X_ADS_ACCOUNT_ID.\";\n\nasync function fetchXAccounts(useCache: boolean): Promise<XAccountInfo[]> {\n  if (useCache) {\n    const cached = cacheGet<XAccountInfo[]>(\"x-accounts\", \"list\");\n    if (cached) return cached.data;\n  }\n  const params = !useCache ? { \"skip-cache\": \"true\" } : undefined;\n  const data = await apiGet<XAccountInfo[]>(\"/api/ads/x/accounts\", params);\n  if (useCache) {\n    cacheSet(\"x-accounts\", \"list\", data, ACCOUNTS_CACHE_TTL_MS);\n  }\n  return data;\n}\n\n/**\n * Resolve an X Ads account_id from either --account-id, BAKER_X_ADS_ACCOUNT_ID, or\n * (if exactly one account is connected) auto-detect.\n */\nexport async function resolveXAccountId(args: Record<string, unknown>): Promise<string> {\n  const fromArgs = args[\"account-id\"] as string | undefined;\n  const accountId = fromArgs || getEnv().BAKER_X_ADS_ACCOUNT_ID;\n  if (accountId) {\n    if (!/^[a-z0-9]+$/.test(accountId)) {\n      writeAdsJson({\n        ok: false,\n        error: {\n          code: \"INVALID_ACCOUNT_ID\",\n          message:\n            \"X Ads account ID must be a base36 string (lowercase letters and digits). Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID.\",\n        },\n      });\n      process.exit(1);\n    }\n    return accountId;\n  }\n\n  const useCache = !args[\"no-cache\"];\n  try {\n    const accounts = await fetchXAccounts(useCache);\n    const [single] = accounts;\n    if (accounts.length === 1 && single) {\n      process.stderr.write(`Using account \"${single.name}\" (${single.id})\\n`);\n      return single.id;\n    }\n    if (accounts.length === 0) {\n      // Not a connection failure — see NO_X_ACCOUNTS_EXPLANATION.\n      writeAdsJson({\n        ok: false,\n        error: {\n          code: \"INVALID_ACCOUNT_ID\",\n          message: NO_X_ACCOUNTS_EXPLANATION,\n          fix: { action: \"reject\", explanation: NO_X_ACCOUNTS_EXPLANATION },\n          retryable: false,\n        },\n      });\n      process.exit(1);\n    }\n    const list = accounts.map((a) => `  ${a.id}  ${a.name}`).join(\"\\n\");\n    writeAdsJson({\n      ok: false,\n      error: {\n        code: \"MULTIPLE_ACCOUNTS\",\n        message: `Multiple X Ads accounts found. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID:\\n${list}`,\n      },\n    });\n    process.exit(1);\n  } catch (err) {\n    if (err instanceof ApiError && needsConnectionFix(err.code, err.message)) {\n      handleConnectionError(\"x_ads\", err.message);\n    }\n    writeAdsJson({\n      ok: false,\n      error: {\n        code: \"INVALID_ACCOUNT_ID\",\n        message: \"Could not auto-detect account. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID.\",\n      },\n    });\n    process.exit(1);\n  }\n}\n\n/**\n * The account's own timezone, which X Ads measures a DAY-granularity window against.\n * Falls back to UTC when the account cannot be read — X names the mismatch clearly enough.\n */\nexport async function resolveXAccountTimezone(accountId: string, args: Record<string, unknown>): Promise<string> {\n  try {\n    const accounts = await fetchXAccounts(!args[\"no-cache\"]);\n    return accounts.find((a) => a.id === accountId)?.timezone || \"UTC\";\n  } catch {\n    return \"UTC\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,IAAM,wBAAwB,KAAK,KAAK;AAQjC,IAAM,4BACX;AAMF,eAAe,eAAe,UAA4C;AACxE,MAAI,UAAU;AACZ,UAAM,SAAS,SAAyB,cAAc,MAAM;AAC5D,QAAI,OAAQ,QAAO,OAAO;AAAA,EAC5B;AACA,QAAM,SAAS,CAAC,WAAW,EAAE,cAAc,OAAO,IAAI;AACtD,QAAM,OAAO,MAAM,OAAuB,uBAAuB,MAAM;AACvE,MAAI,UAAU;AACZ,aAAS,cAAc,QAAQ,MAAM,qBAAqB;AAAA,EAC5D;AACA,SAAO;AACT;AAMA,eAAsB,kBAAkB,MAAgD;AACtF,QAAM,WAAW,KAAK,YAAY;AAClC,QAAM,YAAY,YAAY,OAAO,EAAE;AACvC,MAAI,WAAW;AACb,QAAI,CAAC,cAAc,KAAK,SAAS,GAAG;AAClC,mBAAa;AAAA,QACX,IAAI;AAAA,QACJ,OAAO;AAAA,UACL,MAAM;AAAA,UACN,SACE;AAAA,QACJ;AAAA,MACF,CAAC;AACD,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,CAAC,KAAK,UAAU;AACjC,MAAI;AACF,UAAM,WAAW,MAAM,eAAe,QAAQ;AAC9C,UAAM,CAAC,MAAM,IAAI;AACjB,QAAI,SAAS,WAAW,KAAK,QAAQ;AACnC,cAAQ,OAAO,MAAM,kBAAkB,OAAO,IAAI,MAAM,OAAO,EAAE;AAAA,CAAK;AACtE,aAAO,OAAO;AAAA,IAChB;AACA,QAAI,SAAS,WAAW,GAAG;AAEzB,mBAAa;AAAA,QACX,IAAI;AAAA,QACJ,OAAO;AAAA,UACL,MAAM;AAAA,UACN,SAAS;AAAA,UACT,KAAK,EAAE,QAAQ,UAAU,aAAa,0BAA0B;AAAA,UAChE,WAAW;AAAA,QACb;AAAA,MACF,CAAC;AACD,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,UAAM,OAAO,SAAS,IAAI,CAAC,MAAM,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,IAAI;AAClE,iBAAa;AAAA,MACX,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS;AAAA,EAAoF,IAAI;AAAA,MACnG;AAAA,IACF,CAAC;AACD,YAAQ,KAAK,CAAC;AAAA,EAChB,SAAS,KAAK;AACZ,QAAI,eAAe,YAAY,mBAAmB,IAAI,MAAM,IAAI,OAAO,GAAG;AACxE,4BAAsB,SAAS,IAAI,OAAO;AAAA,IAC5C;AACA,iBAAa;AAAA,MACX,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS;AAAA,MACX;AAAA,IACF,CAAC;AACD,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;AAMA,eAAsB,wBAAwB,WAAmB,MAAgD;AAC/G,MAAI;AACF,UAAM,WAAW,MAAM,eAAe,CAAC,KAAK,UAAU,CAAC;AACvD,WAAO,SAAS,KAAK,CAAC,MAAM,EAAE,OAAO,SAAS,GAAG,YAAY;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-FPZKKNDK.js

@@ -0,0 +1,98 @@
+import {
+  isRemoteUrl
+} from "./chunk-VSU5R34H.js";
+import {
+  detectImageContentType,
+  uploadLocalImage
+} from "./chunk-AG62YO7C.js";
+import {
+  IMAGE_GENERATE_MODELS,
+  MODEL_REGISTRY,
+  VIDEO_GENERATE_MODELS
+} from "./chunk-CAMX6OHF.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CUL3VB4L.js";
+
+// src/commands/studio/modelOptions.ts
+function unionOfStringEnum(node, models, param) {
+  const values = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = MODEL_REGISTRY[node][model]?.params[param];
+    if (schema?.kind === "string") for (const value of schema.enum ?? []) values.add(value);
+  }
+  return [...values];
+}
+function unionOfNumberEnum(node, models, param) {
+  const values = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = MODEL_REGISTRY[node][model]?.params[param];
+    if (schema?.kind === "number") for (const value of schema.enum ?? []) values.add(value);
+  }
+  return [...values].sort((a, b) => a - b);
+}
+var IMAGE_MODEL_IDS = [...IMAGE_GENERATE_MODELS];
+var VIDEO_MODEL_IDS = [...VIDEO_GENERATE_MODELS];
+var IMAGE_SIZES = unionOfStringEnum("image_generate", IMAGE_GENERATE_MODELS, "image_size");
+var IMAGE_QUALITIES = unionOfStringEnum("image_generate", IMAGE_GENERATE_MODELS, "quality");
+var CLIP_RESOLUTIONS = unionOfStringEnum("video_generate", VIDEO_GENERATE_MODELS, "resolution");
+var CLIP_DURATIONS = unionOfNumberEnum("video_generate", VIDEO_GENERATE_MODELS, "duration");
+var CLIP_PERSON_GENERATION = unionOfStringEnum("video_generate", VIDEO_GENERATE_MODELS, "person_generation");
+
+// src/commands/studio/references.ts
+var LIBRARY_ID_RE = /^[a-z0-9]{16,}$/i;
+var FILE_EXTENSION_RE = /\.[a-z0-9]{2,5}$/i;
+var PATH_HINT_RE = /[/\\]/;
+function classify(entry) {
+  if (isRemoteUrl(entry)) return { kind: "url", value: entry };
+  if (PATH_HINT_RE.test(entry) || FILE_EXTENSION_RE.test(entry)) return { kind: "path", value: entry };
+  if (LIBRARY_ID_RE.test(entry)) return { kind: "id", value: entry };
+  throw new ApiError(
+    "VALIDATION_ERROR",
+    `"${entry}" is not a library image id, a file path, or an image URL. Pass a comma-separated mix of those.`
+  );
+}
+function parseImageRefs(spec) {
+  return spec.split(",").map((entry) => entry.trim()).filter(Boolean).map(classify);
+}
+var defaultDeps = {
+  ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
+  upload: (path) => uploadLocalImage({ file: path, contentType: detectImageContentType(path), source: "uploaded" })
+};
+async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
+  const refs = parseImageRefs(spec);
+  if (limit && refs.length > limit.max) {
+    throw new ApiError("VALIDATION_ERROR", limit.refuse(refs.length));
+  }
+  const imageIds = [];
+  const added = [];
+  for (const ref of refs) {
+    if (ref.kind === "id") {
+      imageIds.push(ref.value);
+      continue;
+    }
+    const { imageId } = ref.kind === "url" ? await deps.ingest(ref.value) : await deps.upload(ref.value).catch(uploadFailure(ref.value));
+    imageIds.push(imageId);
+    added.push(imageId);
+  }
+  return { imageIds, added };
+}
+function uploadFailure(path) {
+  return (error) => {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path}" as an image.`);
+  };
+}
+
+export {
+  IMAGE_MODEL_IDS,
+  VIDEO_MODEL_IDS,
+  IMAGE_SIZES,
+  IMAGE_QUALITIES,
+  CLIP_RESOLUTIONS,
+  CLIP_DURATIONS,
+  CLIP_PERSON_GENERATION,
+  resolveLibraryImageIds
+};
+//# sourceMappingURL=chunk-FPZKKNDK.js.map

package/dist/chunk-FPZKKNDK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/studio/modelOptions.ts","../src/commands/studio/references.ts"],"sourcesContent":["import { IMAGE_GENERATE_MODELS, MODEL_REGISTRY, VIDEO_GENERATE_MODELS } from \"@baker/canvas-contract\";\n\n/**\n * What the curated roster accepts for one param, across every model that has it.\n *\n * Derived, never hand-copied: the contract registry is the source of truth for\n * which model takes which value, and a hand-written list in the CLI is a second\n * copy that goes stale the first time a model is added. `baker schema` reads\n * these, so the agent's picture of what is allowed comes from the same place the\n * backend's refusal does.\n *\n * The union is deliberately WIDER than any single model: `--quality 4k` is valid\n * on Seedance and `4K` on Veo (different providers, different casing), and both\n * belong in the advertised set. Whether the chosen model accepts the value the\n * caller picked is settled server-side, per model, with a message that names it.\n */\nfunction unionOfStringEnum(\n  node: \"image_generate\" | \"video_generate\",\n  models: readonly string[],\n  param: string,\n): string[] {\n  const values = new Set<string>();\n  for (const model of models) {\n    const schema = MODEL_REGISTRY[node][model]?.params[param];\n    if (schema?.kind === \"string\") for (const value of schema.enum ?? []) values.add(value);\n  }\n  return [...values];\n}\n\n/** Every number the roster accepts for a param, ascending. */\nfunction unionOfNumberEnum(\n  node: \"image_generate\" | \"video_generate\",\n  models: readonly string[],\n  param: string,\n): number[] {\n  const values = new Set<number>();\n  for (const model of models) {\n    const schema = MODEL_REGISTRY[node][model]?.params[param];\n    if (schema?.kind === \"number\") for (const value of schema.enum ?? []) values.add(value);\n  }\n  return [...values].sort((a, b) => a - b);\n}\n\nexport const IMAGE_MODEL_IDS = [...IMAGE_GENERATE_MODELS];\nexport const VIDEO_MODEL_IDS = [...VIDEO_GENERATE_MODELS];\n\nexport const IMAGE_SIZES = unionOfStringEnum(\"image_generate\", IMAGE_GENERATE_MODELS, \"image_size\");\nexport const IMAGE_QUALITIES = unionOfStringEnum(\"image_generate\", IMAGE_GENERATE_MODELS, \"quality\");\n\nexport const CLIP_RESOLUTIONS = unionOfStringEnum(\"video_generate\", VIDEO_GENERATE_MODELS, \"resolution\");\nexport const CLIP_DURATIONS = unionOfNumberEnum(\"video_generate\", VIDEO_GENERATE_MODELS, \"duration\");\nexport const CLIP_PERSON_GENERATION = unionOfStringEnum(\"video_generate\", VIDEO_GENERATE_MODELS, \"person_generation\");\n","import type { ImagesIngestResponse } from \"@baker/api\";\nimport { ApiError, apiPost } from \"../../client.ts\";\nimport { isRemoteUrl } from \"../../lib/image/io.ts\";\nimport { detectImageContentType, uploadLocalImage } from \"../images/api.ts\";\n\n/**\n * One entry of a `--reference` / `--image` spec, after classification.\n *\n * The studio takes LIBRARY image ids and nothing else: a reference has to be an\n * asset the dashboard can show next to the batch that used it, and inlined bytes\n * would put megabytes of base64 on a row the live feed reads. So the CLI accepts\n * the three things an agent actually has — an id it already knows, a file it just\n * wrote in the workspace, a URL it just found — and turns the last two into\n * library images before starting the batch. That also makes the reference\n * reusable: the next prompt can name the id.\n */\nexport type ImageRef = { kind: \"id\" | \"url\" | \"path\"; value: string };\n\n// Convex ids are long, unpadded alphanumerics with no separators and no\n// extension — distinguishable from both a filename and a prose fragment.\nconst LIBRARY_ID_RE = /^[a-z0-9]{16,}$/i;\nconst FILE_EXTENSION_RE = /\\.[a-z0-9]{2,5}$/i;\nconst PATH_HINT_RE = /[/\\\\]/;\n\nfunction classify(entry: string): ImageRef {\n  if (isRemoteUrl(entry)) return { kind: \"url\", value: entry };\n  if (PATH_HINT_RE.test(entry) || FILE_EXTENSION_RE.test(entry)) return { kind: \"path\", value: entry };\n  if (LIBRARY_ID_RE.test(entry)) return { kind: \"id\", value: entry };\n  throw new ApiError(\n    \"VALIDATION_ERROR\",\n    `\"${entry}\" is not a library image id, a file path, or an image URL. Pass a comma-separated mix of those.`,\n  );\n}\n\n/**\n * Split a comma-separated spec and classify each entry. Order is preserved —\n * models read references positionally, and the first image is the frame a clip\n * starts from.\n */\nexport function parseImageRefs(spec: string): ImageRef[] {\n  return spec\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter(Boolean)\n    .map(classify);\n}\n\nexport type ResolveLibraryImageDeps = {\n  ingest: (url: string) => Promise<ImagesIngestResponse>;\n  upload: (path: string) => Promise<{ imageId: string }>;\n};\n\nconst defaultDeps: ResolveLibraryImageDeps = {\n  ingest: (url) => apiPost<ImagesIngestResponse>(\"/api/images/ingest\", { url, source: \"uploaded\" }),\n  upload: (path) => uploadLocalImage({ file: path, contentType: detectImageContentType(path), source: \"uploaded\" }),\n};\n\n/** How many images the chosen model will take, and what to call them when it won't. */\nexport type ReferenceLimit = { max: number; refuse: (count: number) => string };\n\n/**\n * Turn a `--reference` / `--image` spec into the library image ids the studio\n * takes, adding anything that isn't already in the library.\n *\n * The batch is not started until every entry resolves: half a reference set is\n * a different brief, and paying for it is worse than failing the call.\n *\n * The count is checked FIRST, before a single upload or ingest. The backend\n * checks it too, but by the time it does the CLI has already downloaded and\n * described every image in a set it was always going to refuse — work the\n * caller pays for and then throws away.\n */\nexport async function resolveLibraryImageIds(\n  spec: string,\n  limit?: ReferenceLimit,\n  deps: ResolveLibraryImageDeps = defaultDeps,\n): Promise<{ imageIds: string[]; added: string[] }> {\n  const refs = parseImageRefs(spec);\n  if (limit && refs.length > limit.max) {\n    throw new ApiError(\"VALIDATION_ERROR\", limit.refuse(refs.length));\n  }\n  const imageIds: string[] = [];\n  const added: string[] = [];\n  for (const ref of refs) {\n    if (ref.kind === \"id\") {\n      imageIds.push(ref.value);\n      continue;\n    }\n    const { imageId } =\n      ref.kind === \"url\" ? await deps.ingest(ref.value) : await deps.upload(ref.value).catch(uploadFailure(ref.value));\n    imageIds.push(imageId);\n    added.push(imageId);\n  }\n  return { imageIds, added };\n}\n\nfunction uploadFailure(path: string): (error: unknown) => never {\n  return (error) => {\n    if (error instanceof ApiError) throw error;\n    throw new ApiError(\"VALIDATION_ERROR\", `Could not read \"${path}\" as an image.`);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgBA,SAAS,kBACP,MACA,QACA,OACU;AACV,QAAM,SAAS,oBAAI,IAAY;AAC/B,aAAW,SAAS,QAAQ;AAC1B,UAAM,SAAS,eAAe,IAAI,EAAE,KAAK,GAAG,OAAO,KAAK;AACxD,QAAI,QAAQ,SAAS,SAAU,YAAW,SAAS,OAAO,QAAQ,CAAC,EAAG,QAAO,IAAI,KAAK;AAAA,EACxF;AACA,SAAO,CAAC,GAAG,MAAM;AACnB;AAGA,SAAS,kBACP,MACA,QACA,OACU;AACV,QAAM,SAAS,oBAAI,IAAY;AAC/B,aAAW,SAAS,QAAQ;AAC1B,UAAM,SAAS,eAAe,IAAI,EAAE,KAAK,GAAG,OAAO,KAAK;AACxD,QAAI,QAAQ,SAAS,SAAU,YAAW,SAAS,OAAO,QAAQ,CAAC,EAAG,QAAO,IAAI,KAAK;AAAA,EACxF;AACA,SAAO,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AACzC;AAEO,IAAM,kBAAkB,CAAC,GAAG,qBAAqB;AACjD,IAAM,kBAAkB,CAAC,GAAG,qBAAqB;AAEjD,IAAM,cAAc,kBAAkB,kBAAkB,uBAAuB,YAAY;AAC3F,IAAM,kBAAkB,kBAAkB,kBAAkB,uBAAuB,SAAS;AAE5F,IAAM,mBAAmB,kBAAkB,kBAAkB,uBAAuB,YAAY;AAChG,IAAM,iBAAiB,kBAAkB,kBAAkB,uBAAuB,UAAU;AAC5F,IAAM,yBAAyB,kBAAkB,kBAAkB,uBAAuB,mBAAmB;;;AC/BpH,IAAM,gBAAgB;AACtB,IAAM,oBAAoB;AAC1B,IAAM,eAAe;AAErB,SAAS,SAAS,OAAyB;AACzC,MAAI,YAAY,KAAK,EAAG,QAAO,EAAE,MAAM,OAAO,OAAO,MAAM;AAC3D,MAAI,aAAa,KAAK,KAAK,KAAK,kBAAkB,KAAK,KAAK,EAAG,QAAO,EAAE,MAAM,QAAQ,OAAO,MAAM;AACnG,MAAI,cAAc,KAAK,KAAK,EAAG,QAAO,EAAE,MAAM,MAAM,OAAO,MAAM;AACjE,QAAM,IAAI;AAAA,IACR;AAAA,IACA,IAAI,KAAK;AAAA,EACX;AACF;AAOO,SAAS,eAAe,MAA0B;AACvD,SAAO,KACJ,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAC3B,OAAO,OAAO,EACd,IAAI,QAAQ;AACjB;AAOA,IAAM,cAAuC;AAAA,EAC3C,QAAQ,CAAC,QAAQ,QAA8B,sBAAsB,EAAE,KAAK,QAAQ,WAAW,CAAC;AAAA,EAChG,QAAQ,CAAC,SAAS,iBAAiB,EAAE,MAAM,MAAM,aAAa,uBAAuB,IAAI,GAAG,QAAQ,WAAW,CAAC;AAClH;AAiBA,eAAsB,uBACpB,MACA,OACA,OAAgC,aACkB;AAClD,QAAM,OAAO,eAAe,IAAI;AAChC,MAAI,SAAS,KAAK,SAAS,MAAM,KAAK;AACpC,UAAM,IAAI,SAAS,oBAAoB,MAAM,OAAO,KAAK,MAAM,CAAC;AAAA,EAClE;AACA,QAAM,WAAqB,CAAC;AAC5B,QAAM,QAAkB,CAAC;AACzB,aAAW,OAAO,MAAM;AACtB,QAAI,IAAI,SAAS,MAAM;AACrB,eAAS,KAAK,IAAI,KAAK;AACvB;AAAA,IACF;AACA,UAAM,EAAE,QAAQ,IACd,IAAI,SAAS,QAAQ,MAAM,KAAK,OAAO,IAAI,KAAK,IAAI,MAAM,KAAK,OAAO,IAAI,KAAK,EAAE,MAAM,cAAc,IAAI,KAAK,CAAC;AACjH,aAAS,KAAK,OAAO;AACrB,UAAM,KAAK,OAAO;AAAA,EACpB;AACA,SAAO,EAAE,UAAU,MAAM;AAC3B;AAEA,SAAS,cAAc,MAAyC;AAC9D,SAAO,CAAC,UAAU;AAChB,QAAI,iBAAiB,SAAU,OAAM;AACrC,UAAM,IAAI,SAAS,oBAAoB,mBAAmB,IAAI,gBAAgB;AAAA,EAChF;AACF;","names":[]}