@koda-sl/baker-cli 0.549.0 → 0.551.0-dev.ad2740332

package/dist/draft-R7BNWMBR.js

@@ -1,408 +0,0 @@
-import {
-  draftAction,
-  draftListAction,
-  failWriteValidation,
-  handleGoogleError,
-  loadJsonPayloads,
-  loadPatchArg,
-  requireTarget,
-  stageGoogleOps
-} from "./chunk-DYTBVVQX.js";
-import "./chunk-ERSX3MKH.js";
-import "./chunk-3W4IORXH.js";
-import "./chunk-4NZ47VXO.js";
-import "./chunk-D5FY4FAK.js";
-import "./chunk-NGQ5J4FV.js";
-import "./chunk-QALAJNBG.js";
-import "./chunk-SNWFM2DB.js";
-import {
-  writeJsonEnvelope
-} from "./chunk-MGWAZXY6.js";
-import "./chunk-VWOKPC3T.js";
-import "./chunk-BGT5ZA4L.js";
-import "./chunk-JF2XP76K.js";
-import "./chunk-SYLPRIFM.js";
-import "./chunk-XBR7TSZN.js";
-import "./chunk-DGUN7FUH.js";
-import {
-  CHAT_READ_ARG,
-  DRAFT_FULL_ARG
-} from "./chunk-X32MFGWW.js";
-import "./chunk-NSBNIPIW.js";
-import {
-  GOOGLE_DRAFT_BATCH_MAX
-} from "./chunk-MSMTG6OC.js";
-import {
-  apiPost
-} from "./chunk-B2OHCWYB.js";
-import "./chunk-SVUFNCOE.js";
-import {
-  requireChatId
-} from "./chunk-E54435XT.js";
-import {
-  registerSchema
-} from "./chunk-WCIS4FZH.js";
-import "./chunk-YQSBHWOI.js";
-
-// src/commands/ads/google/draft.ts
-import { defineCommand } from "citty";
-
-// src/commands/ads/google/draft-batch.ts
-function refuseOversized(count, what) {
-  if (count > GOOGLE_DRAFT_BATCH_MAX) {
-    failWriteValidation(
-      `${count} ${what} exceeds the batch limit of ${GOOGLE_DRAFT_BATCH_MAX} \u2014 split the file and run the command once per part`
-    );
-  }
-}
-function stageFileOps(items, customerId) {
-  if (items.length === 0) {
-    failWriteValidation(
-      'pass --file with the ops to stage: a JSON array (or JSON Lines) of {"kind","customerId","target"?,"payload"?}'
-    );
-  }
-  refuseOversized(items.length, "ops");
-  return items.map((item, index) => {
-    if (typeof item.kind !== "string") {
-      failWriteValidation(
-        `item ${index} has no "kind" \u2014 every item is a whole op, e.g. {"kind":"google.keyword.add",\u2026}`
-      );
-    }
-    return item.customerId === void 0 && customerId ? { ...item, customerId } : item;
-  });
-}
-function amendBatchEntries(items) {
-  refuseOversized(items.length, "amends");
-  return items.map((item, index) => {
-    const { ref, patch } = item;
-    if (typeof ref !== "string" || ref.length === 0) {
-      failWriteValidation(`item ${index} has no "ref" \u2014 name the staged op (g_temp_* or its target) to amend`);
-    }
-    if (patch === null || typeof patch !== "object" || Array.isArray(patch)) {
-      failWriteValidation(`item ${index} has no "patch" object \u2014 {"ref":"\u2026","patch":{\u2026fields to change\u2026}}`);
-    }
-    return { ref, patch };
-  });
-}
-
-// src/commands/ads/google/draft-validate.ts
-var QUIET = /* @__PURE__ */ new Set(["accepted", "applied"]);
-function changes(n) {
-  return n === 1 ? "1 change" : `${n} changes`;
-}
-function validationHints(data) {
-  const { refused, blocked, unchecked } = data.counts;
-  const hints = [];
-  if (refused > 0) {
-    hints.push(
-      `${changes(refused)} would fail at publish. Fix each refused op in place with \`draft amend <ref>\` (or \`draft remove <ref>\` if it should not exist), then run \`draft validate\` again before asking the user to publish. Never tell the user a refused change will go live.`
-    );
-  }
-  if (blocked > 0) {
-    hints.push(
-      `${changes(blocked)} would not apply only because a refused change they depend on fails \u2014 fixing the refused one clears them.`
-    );
-  }
-  if (data.publishHeld) {
-    hints.push(
-      "Baker would hold this whole publish: a refused change stops a first publish from sending anything. Fix it first."
-    );
-  }
-  if (unchecked > 0) {
-    hints.push(
-      `${changes(unchecked)} can only be checked by Google at publish (the reason is on each one). Nothing here says they will fail.`
-    );
-  }
-  if (refused + blocked === 0 && !data.publishHeld && data.ops.length > 0) {
-    hints.push(
-      "Google accepted every change it was asked about. The draft is ready for the user to review and publish."
-    );
-  }
-  return hints;
-}
-function validationEnvelope(data, full = false) {
-  const ops = full ? data.ops : data.ops.filter((op) => !QUIET.has(op.verdict));
-  return { ok: true, data: { ...data, ops }, hints: validationHints(data) };
-}
-
-// src/commands/ads/google/draft.ts
-var VALIDATE_DESCRIPTION = `Ask Google whether the whole staged draft would publish \u2014 without applying anything.
-
-Start here, after the last staged change and before telling the user the draft is ready:
-  baker ads google draft validate
-
-Every staged op is built, batched and sent exactly as publish sends it, with Google's validateOnly
-flag, so each verdict is the answer publish would get: accepted | refused | blocked (a change it
-depends on was refused) | unchecked (only publish can check it) | applied (an earlier publish did).
-Compact by default \u2014 counts, plus only the ops that need attention, each with Google's reason.
-Fix refused ops with \`draft amend <ref>\` and validate again.
-
-Examples:
-  baker ads google draft validate
-  baker ads google draft validate --full   # every op, with its built request and Google's raw answer`;
-registerSchema({
-  command: "ads.google.draft.validate",
-  description: VALIDATE_DESCRIPTION,
-  args: {
-    full: {
-      type: "boolean",
-      description: "List every op with its built request and Google's raw answer",
-      required: false
-    }
-  }
-});
-var STAGE_DESCRIPTION = `Stage many Google Ads changes from ONE file, in one call \u2014 any mix of kinds, up to 500 ops.
-
-Start here whenever a change touches more than a few rows (a keyword cleanup, bid changes, pausing
-ads, a list of negatives): write the ops to a file and stage them together instead of running one
-command per row.
-  baker ads google draft stage --file changes.json --customer-id 1234567890
-
-The file is a JSON array (or JSON Lines, one op per line). Each op is what the single commands
-build \u2014 kind, customerId (or --customer-id for all), target for a change to something that exists,
-payload. Read the shape for a kind with \`baker capabilities google-ads\`.
-  [
-    {"kind":"google.keyword.add","payload":{"adGroup":"customers/1234567890/adGroups/111","text":"solar panels","matchType":"PHRASE"}},
-    {"kind":"google.keyword.update","target":"customers/1234567890/adGroupCriteria/111~222","payload":{"status":"PAUSED"}},
-    {"kind":"google.negativeKeyword.add","payload":{"level":"campaign","parent":"222333","text":"free","matchType":"BROAD"}}
-  ]
-An op may name a g_temp_* ref an EARLIER call returned (a campaign or ad group staged before), but
-not another op in the same file \u2014 a ref exists only once its op is staged, so stage new parents first.
-All-or-nothing: one invalid op stages nothing. Ops already in effect come back as skipped.
-Then: baker ads google draft validate`;
-registerSchema({
-  command: "ads.google.draft.stage",
-  description: STAGE_DESCRIPTION,
-  args: {
-    file: {
-      type: "string",
-      description: "JSON array or JSON Lines of ops ({kind, customerId?, target?, payload?}), path or inline",
-      required: true
-    },
-    "customer-id": {
-      type: "string",
-      description: "10-digit customer id for every op that does not name its own",
-      required: false
-    }
-  }
-});
-var IMPORT_DESCRIPTION = `Move another open chat's staged Google Ads changes into this chat, in one call \u2014 and out of that chat, so the two can never publish the same change twice.
-
-Start here when the user wants another chat's changes brought into this one ("bring over", "merge",
-"include what the other chat prepared", "all of them except \u2026"):
-  baker ads google draft import --from-chat <chat-id>
-  baker ads google draft import --from-chat <chat-id> --exclude g_temp_a,customers/123/adGroupAds/4~5
-  baker ads google draft import --from-chat <chat-id> --refs g_temp_b
-
-Every op moves exactly as it was staged \u2014 same ref, same payload, nothing retyped \u2014 so never copy
-another chat's changes with \`draft show --chat\` and re-stage them. An op moves with the creates it
-depends on and the ops that depend on it (an asset and the link that attaches it go together).
-The other chat must still be open; its other work (Knowledge, Tasks) stays where it is. Find chat ids
-with \`baker chats list\`, and refs with \`baker ads google draft list --chat <chat-id> --json\`.
-Then: baker ads google draft validate`;
-registerSchema({
-  command: "ads.google.draft.import",
-  description: IMPORT_DESCRIPTION,
-  args: {
-    "from-chat": { type: "string", description: "The other open chat whose staged changes move here", required: true },
-    refs: {
-      type: "string",
-      description: "Comma-separated refs to move (default: all); what they depend on comes too",
-      required: false
-    },
-    exclude: {
-      type: "string",
-      description: "Comma-separated refs to leave in the other chat, with the ops that depend on them",
-      required: false
-    }
-  }
-});
-var LIST_DESCRIPTION = "Review everything staged as a campaign \u25B8 ad group \u25B8 ad tree (--json for the raw envelope, --full for every op's payload too)";
-registerSchema({
-  command: "ads.google.draft.list",
-  description: LIST_DESCRIPTION,
-  args: {
-    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree", required: false },
-    full: { type: "boolean", description: DRAFT_FULL_ARG.description, required: false },
-    chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
-  }
-});
-function refList(value) {
-  if (typeof value !== "string") return void 0;
-  const refs = value.split(",").map((ref) => ref.trim()).filter((ref) => ref.length > 0);
-  return refs.length > 0 ? refs : null;
-}
-function importHints(fromChatId, data) {
-  const source = data.sourceRemaining > 0 ? `Chat ${fromChatId} still has ${data.sourceRemaining} Google Ads change(s) staged, which publish with that chat.` : `Chat ${fromChatId} has no Google Ads changes staged any more, so publishing it cannot apply these twice. Its other work stays there \u2014 never tell the user to discard it for this.`;
-  return [source, "Run `baker ads google draft validate` next."];
-}
-var BULK_STAGE_HINTS = [
-  "Run `baker ads google draft validate` next: it asks Google about every staged op at once and lists only the ones it would refuse.",
-  'To fix several staged ops, amend them together: `baker ads google draft amend --file amends.json` with [{"ref":"\u2026","patch":{\u2026}}, \u2026].'
-];
-var draftCommand = defineCommand({
-  meta: {
-    name: "draft",
-    description: "Stage many ops from one file, or list, validate, remove, clear, amend, or show staged Google Ads write ops for this chat. `list` and `show` take --chat <id> to read an earlier chat's changes instead; `import --from-chat <id>` moves another open chat's staged changes here."
-  },
-  subCommands: {
-    stage: defineCommand({
-      meta: { name: "stage", description: STAGE_DESCRIPTION },
-      args: {
-        file: {
-          type: "string",
-          description: "JSON array or JSON Lines of ops ({kind, customerId?, target?, payload?}), path or inline"
-        },
-        "customer-id": { type: "string", description: "10-digit customer id for every op that does not name its own" }
-      },
-      run: async ({ args }) => {
-        const customerId = typeof args["customer-id"] === "string" ? args["customer-id"] : void 0;
-        await stageGoogleOps(stageFileOps(loadJsonPayloads(args.file), customerId), BULK_STAGE_HINTS);
-      }
-    }),
-    import: defineCommand({
-      meta: { name: "import", description: IMPORT_DESCRIPTION },
-      args: {
-        "from-chat": { type: "string", description: "The other open chat whose staged changes move here" },
-        refs: { type: "string", description: "Comma-separated refs to move (default: all)" },
-        exclude: { type: "string", description: "Comma-separated refs to leave in the other chat" }
-      },
-      run: async ({ args }) => {
-        const fromChatId = typeof args["from-chat"] === "string" ? args["from-chat"].trim() : "";
-        if (!fromChatId) {
-          writeJsonEnvelope({
-            ok: false,
-            error: {
-              code: "VALIDATION_ERROR",
-              message: "--from-chat is required",
-              fix: "Name the other chat: baker ads google draft import --from-chat <chat-id> (ids from `baker chats list`)."
-            }
-          });
-          process.exit(1);
-        }
-        const refs = refList(args.refs);
-        const exclude = refList(args.exclude);
-        const empty = refs === null ? "--refs" : exclude === null ? "--exclude" : void 0;
-        if (empty) {
-          writeJsonEnvelope({
-            ok: false,
-            error: {
-              code: "VALIDATION_ERROR",
-              message: `${empty} names no change`,
-              fix: `Pass the refs, comma-separated (from \`baker ads google draft list --chat ${fromChatId} --json\`), or leave ${empty} off to move every change.`
-            }
-          });
-          process.exit(1);
-        }
-        try {
-          const response = await apiPost(
-            "/api/ads/google/draft/import",
-            { chatId: requireChatId(), fromChatId, refs: refs ?? void 0, exclude: exclude ?? void 0 }
-          );
-          writeJsonEnvelope(
-            response.ok && response.data ? { ...response, hints: importHints(fromChatId, response.data) } : response
-          );
-        } catch (err) {
-          handleGoogleError(err);
-        }
-      }
-    }),
-    list: defineCommand({
-      meta: {
-        name: "list",
-        description: LIST_DESCRIPTION
-      },
-      args: {
-        json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" },
-        full: DRAFT_FULL_ARG,
-        chat: CHAT_READ_ARG
-      },
-      run: async ({ args }) => {
-        await draftListAction(args.json === true, args.chat, args.full === true);
-      }
-    }),
-    remove: defineCommand({
-      meta: { name: "remove", description: "Remove one staged op (cascades to dependents)" },
-      args: { ref: { type: "positional", description: "Staged op ref (g_temp_* or target)", required: false } },
-      run: async ({ args }) => {
-        await draftAction("/api/ads/google/draft/remove", { ref: requireTarget(args, "op") });
-      }
-    }),
-    clear: defineCommand({
-      meta: { name: "clear", description: "Discard all staged ops on this chat" },
-      run: async () => {
-        await draftAction("/api/ads/google/draft/clear", {});
-      }
-    }),
-    amend: defineCommand({
-      meta: {
-        name: "amend",
-        description: 'Update a staged op in place \u2014 merges a JSON patch into its payload (RFC-7386: objects deep-merge, null deletes a key, arrays/scalars replace) and re-validates. Use this instead of remove + re-create. Many at once: no ref, and --file holding [{"ref":"g_temp_\u2026","patch":{\u2026}}, \u2026] \u2014 all amended in one call, or none if any is refused.'
-      },
-      args: {
-        ref: {
-          type: "positional",
-          description: "Staged op ref (g_temp_*) or target id/resource name \u2014 leave out to amend many from --file",
-          required: false
-        },
-        file: {
-          type: "string",
-          description: 'JSON file with the patch object \u2014 or, with no ref, a JSON array of {"ref","patch"} amends'
-        },
-        patch: { type: "string", description: "Inline JSON patch object" }
-      },
-      run: async ({ args }) => {
-        const positional = Array.isArray(args._) ? args._[0] : void 0;
-        if (!(args.ref ?? positional) && typeof args.file === "string" && args.file.length > 0) {
-          const amends = amendBatchEntries(loadJsonPayloads(args.file));
-          await draftAction("/api/ads/google/draft/amend-batch", { amends });
-          return;
-        }
-        const ref = requireTarget(args, "op");
-        const patch = loadPatchArg(args);
-        await draftAction("/api/ads/google/draft/amend", { ref, patch });
-      }
-    }),
-    validate: defineCommand({
-      meta: { name: "validate", description: VALIDATE_DESCRIPTION },
-      args: {
-        full: { type: "boolean", description: "List every op with its built request and Google's raw answer" }
-      },
-      run: async ({ args }) => {
-        try {
-          const full = args.full === true;
-          const response = await apiPost(
-            "/api/ads/google/draft/validate",
-            { chatId: requireChatId(), full }
-          );
-          writeJsonEnvelope(response.ok && response.data ? validationEnvelope(response.data, full) : response);
-        } catch (err) {
-          handleGoogleError(err);
-        }
-      }
-    }),
-    show: defineCommand({
-      meta: {
-        name: "show",
-        description: "Print the full staged payload for one op \u2014 the receipt to verify a change looks right before publish (never truncated)."
-      },
-      args: {
-        ref: {
-          type: "positional",
-          description: "Staged op ref (g_temp_*) or target id/resource name",
-          required: false
-        },
-        chat: CHAT_READ_ARG
-      },
-      run: async ({ args }) => {
-        await draftAction("/api/ads/google/draft/show", { ref: requireTarget(args, "op") }, args.chat);
-      }
-    })
-  }
-});
-export {
-  BULK_STAGE_HINTS,
-  draftCommand,
-  importHints
-};
-//# sourceMappingURL=draft-R7BNWMBR.js.map

package/dist/experiments-C3M65LMP.js

@@ -1,236 +0,0 @@
-import {
-  bareAccountId,
-  failWriteValidation,
-  parseDateFlag,
-  requireTarget,
-  stageOp
-} from "./chunk-I6JPTDKR.js";
-import {
-  handleLinkedinError
-} from "./chunk-IGIACW2B.js";
-import "./chunk-3W4IORXH.js";
-import "./chunk-4NZ47VXO.js";
-import "./chunk-D5FY4FAK.js";
-import "./chunk-NGQ5J4FV.js";
-import {
-  writeJsonEnvelope
-} from "./chunk-MGWAZXY6.js";
-import "./chunk-VWOKPC3T.js";
-import "./chunk-BGT5ZA4L.js";
-import "./chunk-JF2XP76K.js";
-import "./chunk-SYLPRIFM.js";
-import "./chunk-XBR7TSZN.js";
-import "./chunk-DGUN7FUH.js";
-import "./chunk-VR2AF7I7.js";
-import "./chunk-QV6AST5T.js";
-import "./chunk-WCU362Z6.js";
-import "./chunk-GIWHHCD6.js";
-import "./chunk-SOPVIIUW.js";
-import "./chunk-G4FG5EQO.js";
-import "./chunk-NSBNIPIW.js";
-import "./chunk-MSMTG6OC.js";
-import {
-  apiGet
-} from "./chunk-B2OHCWYB.js";
-import "./chunk-SVUFNCOE.js";
-import "./chunk-E54435XT.js";
-import "./chunk-WCIS4FZH.js";
-import "./chunk-YQSBHWOI.js";
-
-// src/commands/ads/linkedin/experiments.ts
-import { defineCommand } from "citty";
-var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads linkedin draft`.";
-var accountArgs = {
-  "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
-  "account-urn": { type: "string", description: "Alias for --account-id" }
-};
-var STOP_AT = {
-  "end-date": "AUTO_STOP_AT_END_DATE",
-  winner: "AUTO_STOP_AT_WINNER",
-  never: "AUTO_STOP_DISABLED"
-};
-function stopAtArg(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const mapped = STOP_AT[String(value)];
-  if (!mapped) {
-    failWriteValidation(`--stop-at must be one of ${Object.keys(STOP_AT).join("|")}`);
-  }
-  return mapped;
-}
-function numberArg(value, flag) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed)) {
-    failWriteValidation(`${flag} must be a whole number`);
-  }
-  return parsed;
-}
-var experimentsListCommand = defineCommand({
-  meta: {
-    name: "list",
-    description: "List the ad account's A/B tests, newest first: name, state (what was asked), running (what LinkedIn is doing: PENDING|RUNNING|ON_HOLD|STOPPED|ENDED), metric, dates and the two versions (ad sets + traffic split). Runs by default."
-  },
-  args: { ...accountArgs },
-  run: async ({ args }) => {
-    try {
-      const data = await apiGet("/api/ads/linkedin/experiments", {
-        "account-id": bareAccountId(args)
-      });
-      writeJsonEnvelope({ ok: true, data });
-    } catch (err) {
-      handleLinkedinError(err);
-    }
-  }
-});
-var experimentsGetCommand = defineCommand({
-  meta: {
-    name: "get",
-    description: "One A/B test with LinkedIn's setup checks (an ERROR keeps it from running \u2014 e.g. NO_ACTIVE_CREATIVES; a WARNING may skew it) and its latest result: the winning version, p-value, and each version's confidence interval for the metric. `result: null` until LinkedIn computes the first one (daily)."
-  },
-  args: {
-    id: { type: "positional", description: "A/B test id from `experiments`", required: true },
-    ...accountArgs
-  },
-  run: async ({ args }) => {
-    try {
-      const data = await apiGet("/api/ads/linkedin/experiments", {
-        "account-id": bareAccountId(args),
-        id: requireTarget(args, "A/B test")
-      });
-      writeJsonEnvelope({ ok: true, data });
-    } catch (err) {
-      handleLinkedinError(err);
-    }
-  }
-});
-var experimentsCreateCommand = defineCommand({
-  meta: {
-    name: "create",
-    description: `Stage an A/B test between two ad sets of the SAME campaign: LinkedIn splits the audience so each member sees only one version, and calls a winner on the metric. ${STAGED_NOTE}
-Rules LinkedIn enforces: exactly 2 ad sets, same campaign, that campaign must NOT share its budget across ad sets, at most 90 days, confidence 51\u201399 (90+ recommended), each ad set needs an active ad. Best practice: two new ad sets identical but for the one thing tested, equal budgets, 3+ weeks.
-Examples:
-  baker ads linkedin experiments create --name "Image vs video" --version-a li_temp_x1 --version-b li_temp_x2 --metric CPC --start 2026-11-01 --end 2026-11-28
-  baker ads linkedin experiments create --name "Headline test" --version-a 896802423 --name-a "Pain" --version-b 896812053 --name-b "Gain" --metric CPM --start 2026-11-01 --end 2026-12-01 --stop-at winner --confidence 95`
-  },
-  args: {
-    ...accountArgs,
-    name: { type: "string", description: "Test name (\u2264100)", required: true },
-    description: { type: "string", description: "What is being tested" },
-    "version-a": { type: "string", description: "Ad set id/URN or li_temp_* ref for version A", required: true },
-    "version-b": { type: "string", description: "Ad set id/URN or li_temp_* ref for version B", required: true },
-    "name-a": { type: "string", description: "Version A label (default A)" },
-    "name-b": { type: "string", description: "Version B label (default B)" },
-    "weight-a": { type: "string", description: "Version A share of the audience, 1\u201399 (default 50; B gets the rest)" },
-    metric: { type: "string", description: "CPC|CPM|CPV (video ad sets)|CPMS (message ads)", required: true },
-    confidence: { type: "string", description: "51\u201399 (default 90)" },
-    start: { type: "string", description: "Start date (ISO or epoch ms)", required: true },
-    end: { type: "string", description: "End date (\u226490 days after start)", required: true },
-    "stop-at": {
-      type: "string",
-      description: "end-date (default, pauses both) | winner | never (ad sets keep running)"
-    },
-    draft: { type: "boolean", description: "Create it set up but not running" }
-  },
-  run: async ({ args }) => {
-    const weightA = numberArg(args["weight-a"], "--weight-a") ?? 50;
-    await stageOp({
-      kind: "experiment.create",
-      accountId: bareAccountId(args),
-      payload: {
-        name: args.name,
-        description: args.description,
-        keyMetric: args.metric ? String(args.metric).toUpperCase() : void 0,
-        confidence: numberArg(args.confidence, "--confidence"),
-        start: parseDateFlag(args.start, "--start"),
-        end: parseDateFlag(args.end, "--end"),
-        autoStop: stopAtArg(args["stop-at"]),
-        state: args.draft ? "DRAFT" : void 0,
-        cells: [
-          { name: args["name-a"] ?? "A", campaign: args["version-a"], trafficWeight: weightA },
-          { name: args["name-b"] ?? "B", campaign: args["version-b"], trafficWeight: 100 - weightA }
-        ]
-      }
-    });
-  }
-});
-var experimentsUpdateCommand = defineCommand({
-  meta: {
-    name: "update",
-    description: `Stage changes to an A/B test. Once it has started only the name, description, end date (still \u226490 days from start), confidence and when it stops can change \u2014 the versions are fixed. ${STAGED_NOTE}
-Example: baker ads linkedin experiments update 5633011 --end 2026-12-15 --stop-at winner`
-  },
-  args: {
-    id: { type: "positional", description: "A/B test id", required: true },
-    ...accountArgs,
-    name: { type: "string", description: "New name" },
-    description: { type: "string", description: "New description" },
-    end: { type: "string", description: "New end date" },
-    confidence: { type: "string", description: "51\u201399" },
-    "stop-at": { type: "string", description: "end-date|winner|never" }
-  },
-  run: async ({ args }) => {
-    await stageOp({
-      kind: "experiment.update",
-      accountId: bareAccountId(args),
-      target: requireTarget(args, "A/B test"),
-      payload: {
-        name: args.name,
-        description: args.description,
-        end: parseDateFlag(args.end, "--end"),
-        confidence: numberArg(args.confidence, "--confidence"),
-        autoStop: stopAtArg(args["stop-at"])
-      }
-    });
-  }
-});
-function experimentStateCommand(name, state, what) {
-  return defineCommand({
-    meta: {
-      name,
-      description: `Stage ${what}. ${STAGED_NOTE}
-Example: baker ads linkedin experiments ${name} 5633011`
-    },
-    args: {
-      id: { type: "positional", description: "A/B test id", required: true },
-      ...accountArgs
-    },
-    run: async ({ args }) => {
-      await stageOp({
-        kind: "experiment.update",
-        accountId: bareAccountId(args),
-        target: requireTarget(args, "A/B test"),
-        payload: { state }
-      });
-    }
-  });
-}
-var experimentsCommand = defineCommand({
-  meta: {
-    name: "experiments",
-    description: `LinkedIn A/B tests: two ad sets of one campaign shown to separate halves of the audience, with a winner called on CPC/CPM/CPV/CPMS.
-Examples:
-  baker ads linkedin experiments                       # list
-  baker ads linkedin experiments get 5633011           # setup checks + result
-  baker ads linkedin experiments create --name "Image vs video" --version-a <ad set> --version-b <ad set> --metric CPC --start 2026-11-01 --end 2026-11-28
-  baker ads linkedin experiments pause|start|end 5633011`
-  },
-  subCommands: {
-    list: experimentsListCommand,
-    get: experimentsGetCommand,
-    create: experimentsCreateCommand,
-    update: experimentsUpdateCommand,
-    start: experimentStateCommand("start", "ACTIVE", "starting (or resuming) an A/B test"),
-    pause: experimentStateCommand("pause", "PAUSED", "pausing an A/B test \u2014 both ad sets pause, the end date stays"),
-    end: experimentStateCommand("end", "CANCELED", "ending an A/B test for good")
-  },
-  args: { ...accountArgs },
-  default: "list"
-});
-export {
-  experimentsCommand
-};
-//# sourceMappingURL=experiments-C3M65LMP.js.map