@koda-sl/baker-cli 0.538.0 → 0.540.0-dev.91934cfea

package/dist/chunk-NIP6EWVK.js

@@ -0,0 +1,142 @@
+import {
+  avatarsOf
+} from "./chunk-HSUPSA7N.js";
+import {
+  readAvatars
+} from "./chunk-LXV2U4MI.js";
+import {
+  readCreativeContext,
+  workspaceOfCreative
+} from "./chunk-YRNLPGAV.js";
+import {
+  frontmatterOf,
+  ruleTells
+} from "./chunk-YAX5CGUY.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-CM2LECNX.js";
+import {
+  isAdSpec,
+  nativeCopy,
+  readAdSpec
+} from "./chunk-2OCUXPWT.js";
+import {
+  marketFromCompanyDoc
+} from "./chunk-2WZI36D3.js";
+
+// src/engine/creative-context/ad-words.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+var json = (file) => readFile(file, "utf8").then((raw) => JSON.parse(raw)).catch(() => null);
+var text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function waivedOf(spec) {
+  const waive = spec?.waive;
+  return Array.isArray(waive) ? waive.flatMap((w) => text(w?.rule) ?? []) : [];
+}
+function sceneWords(scene) {
+  const s = scene ?? {};
+  const spoken = Array.isArray(s.dialogue) ? s.dialogue.flatMap((d) => text(d?.line) ?? []) : [];
+  const shown = Array.isArray(s.overlays) ? s.overlays.flatMap((o) => text(o?.text) ?? []) : [];
+  return [...spoken, ...shown];
+}
+async function sceneFiles(creativeDir) {
+  const dir = path.join(creativeDir, "scenes");
+  const files = (await readdir(dir).catch(() => [])).filter((f) => f.endsWith(".json")).sort();
+  return await Promise.all(files.map((f) => json(path.join(dir, f))));
+}
+async function videoLanguage(creativeDir) {
+  const definition = frontmatterOf(await readFile(path.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const beats = await json(path.join(creativeDir, "ad.spec.json"));
+  return text(definition?.language) ?? text(beats?.voice?.language);
+}
+async function videoWords(raw, creativeDir) {
+  const global = raw.global ?? {};
+  const transcript = text(global.transcript);
+  const scenes = [...Array.isArray(raw.scenes) ? raw.scenes : [], ...await sceneFiles(creativeDir)];
+  const lines = [.../* @__PURE__ */ new Set([...transcript ? [transcript] : [], ...scenes.flatMap(sceneWords)])];
+  const language = await videoLanguage(creativeDir);
+  return { kind: "video", lines, ...language ? { language } : {} };
+}
+function staticWords(raw) {
+  try {
+    const spec = readAdSpec(raw);
+    const lines = spec.native ? nativeCopy(spec.native) : spec.copy.map((l) => l.text);
+    const language = spec.viewer?.market?.language;
+    return { kind: "static", lines, ...language ? { language } : {} };
+  } catch {
+    return null;
+  }
+}
+async function readAdWords(creativeDir) {
+  const raw = await json(path.join(creativeDir, "prompt.json"));
+  if (!raw || typeof raw !== "object") return null;
+  const video = !isAdSpec(raw) && ("global" in raw || "scenes" in raw);
+  const words = video ? await videoWords(raw, creativeDir) : staticWords(raw);
+  if (!words) return null;
+  const product = text(raw.product);
+  const definition = frontmatterOf(await readFile(path.join(creativeDir, "_definition.md"), "utf8").catch(() => ""));
+  const platform = text(definition?.platform);
+  const listed = definition?.platforms;
+  const platforms = Array.isArray(listed) ? listed.map(text).filter((p) => p !== void 0) : [];
+  return {
+    ...words,
+    ...product ? { product } : {},
+    ...platform ? { platform } : {},
+    ...platforms.length > 0 ? { platforms } : {},
+    waived: waivedOf(raw)
+  };
+}
+
+// src/commands/canvas/rule-gate.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+function tellLine(tell) {
+  const where = tell.kind === "forbidden" ? `"${tell.line ?? ""}" says "${tell.phrase}"` : `No line says "${tell.phrase}"`;
+  const words = tell.quote ? ` Their words: ${tell.quote}` : "";
+  return `${where}: ${tell.rule} (${tell.strength}) \u2014 ${tell.text}${words}`;
+}
+function ruleRefusal(tells) {
+  if (tells.length === 0) return null;
+  return {
+    problems: [...new Set(tells.map(tellLine))],
+    fix: 'Rewrite each line named above within its rule (a static: its `copy` in prompt.json; a video: its scene files and ad.spec.json), then re-run. Only when the person explicitly asked for these words in this ad, keep them and add to prompt.json `"waive": [{"rule": "<id>", "why": "<their ask>"}]`.'
+  };
+}
+var liveRoster = () => readAvatars("/api/avatars", { status: "ready" }).then(avatarsOf, () => null);
+async function heldRules(creativeDir, ad) {
+  const words = ad === void 0 ? await readAdWords(creativeDir) : ad;
+  const root = findWorkspaceRoot(creativeDir) ?? workspaceOfCreative(creativeDir);
+  const context = await readCreativeContext(
+    root,
+    {
+      ...words ? { kind: words.kind } : {},
+      ...words?.product ? { product: words.product } : {},
+      ...words?.platform ? { platform: words.platform } : {},
+      ...words?.platforms ? { platforms: words.platforms } : {}
+    },
+    { waived: words?.waived ?? [] }
+  );
+  const language = words?.language ?? marketFromCompanyDoc(await readFile2(path2.join(root, "COMPANY.md"), "utf8").catch(() => null))?.language;
+  return { rules: context.rules, ...language ? { language } : {} };
+}
+async function ruleGate(creativeDir, roster = liveRoster) {
+  const ad = await readAdWords(creativeDir);
+  if (!ad) return { broken: null, realOnly: null };
+  const { rules, language } = await heldRules(creativeDir, ad);
+  const people = rules.find((r) => r.check?.people === "real" && r.strength !== "prefer");
+  return {
+    broken: ruleRefusal(ruleTells(ad.lines, rules, language)),
+    realOnly: people ? {
+      rule: { id: people.id, text: people.text, ...people.source.quote ? { quote: people.source.quote } : {} },
+      avatars: await roster().catch(() => null)
+    } : null
+  };
+}
+
+export {
+  readAdWords,
+  ruleRefusal,
+  heldRules,
+  ruleGate
+};
+//# sourceMappingURL=chunk-NIP6EWVK.js.map

package/dist/chunk-NOCMEK6R.js

@@ -0,0 +1,377 @@
+import {
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-R6XSLSBI.js";
+import {
+  adCopyHints,
+  booleanWordPositionalError,
+  capabilityFix
+} from "./chunk-MM6CCIL7.js";
+import {
+  withHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-EAHBTBVR.js";
+import {
+  LINKEDIN_DRAFT_BATCH_MAX,
+  linkedinDraftOpInputSchema,
+  listColumnField
+} from "./chunk-HXJTZJ7R.js";
+import {
+  maskPersonValue
+} from "./chunk-SOPVIIUW.js";
+import {
+  apiPost
+} from "./chunk-C35UMKYG.js";
+import {
+  requireChatId
+} from "./chunk-LBIF6FJY.js";
+
+// src/commands/ads/linkedin/write-shared.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+
+// src/commands/ads/linkedin/approval-hint.ts
+function approvalHints(op, staged) {
+  if (!staged.authorApprovalPending) return [];
+  const postId = staged.sponsoredPostId ?? op.payload.content?.bakerPostId ?? "<post id>";
+  return [
+    `If the user says the author already approved this post for this ad account, record it \u2014 \`baker posts approved ${postId} --account-id ${op.accountId}\` \u2014 and the reminder stops. Don't record it on a guess.`
+  ];
+}
+
+// src/commands/ads/linkedin/write-shared.ts
+var TOTAL_BUDGET_HELP = "Lifetime budget \u2014 on something already running it must exceed spend to date, or LinkedIn rejects it";
+function bareAccountId(args) {
+  const raw = resolveAccountIdArg(args);
+  return raw.replace(/^urn:li:sponsoredAccount:/, "").replace(/^sponsoredAccount:/, "");
+}
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function loadJsonFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation(`${path} must contain a JSON object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`${path} 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 loadPatchArg(args) {
+  const file = typeof args.file === "string" && args.file.length > 0 ? args.file : void 0;
+  const inline = typeof args.patch === "string" && args.patch.length > 0 ? args.patch : void 0;
+  if (Boolean(file) === Boolean(inline)) {
+    failWriteValidation("pass exactly one of --file <patch.json> or --patch '<json>'");
+  }
+  if (file) {
+    return loadJsonFileArg(file);
+  }
+  try {
+    const parsed = JSON.parse(inline);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation("--patch must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`--patch is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+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 EUR)`);
+  }
+  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 (raw.toLowerCase() === "now") {
+    return Date.now();
+  }
+  if (/^\d{10,}$/.test(raw)) {
+    return Number(raw);
+  }
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    failWriteValidation(`${flag} must be now, an ISO date (2026-07-10) or epoch milliseconds`);
+  }
+  return parsed;
+}
+function parseOnOffFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value).toLowerCase();
+  if (raw === "on" || raw === "true") {
+    return true;
+  }
+  if (raw === "off" || raw === "false") {
+    return false;
+  }
+  failWriteValidation(`${flag} must be on|off`);
+}
+function parseLocaleFlag(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const match = /^([a-z]{2})[_-]([A-Za-z]{2})$/.exec(String(value));
+  if (!match) {
+    failWriteValidation("--locale must look like en_US (language_COUNTRY)");
+  }
+  return { language: match[1], country: match[2].toUpperCase() };
+}
+function loadTargetingFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return void 0;
+  }
+  const parsed = loadJsonFileArg(path);
+  const criteria = parsed.targetingCriteria ?? parsed;
+  if (!criteria.include) {
+    failWriteValidation(
+      `${path} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+    );
+  }
+  return criteria;
+}
+var SHA256_HEX = /^[0-9a-f]{64}$/i;
+function sha256Lower(value) {
+  const email = value.trim().toLowerCase();
+  return SHA256_HEX.test(email) ? email : createHash("sha256").update(email).digest("hex");
+}
+function emailPreview(email) {
+  return email === "" || SHA256_HEX.test(email.trim()) ? "" : maskPersonValue("email", email);
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current);
+  return cells.map((cell) => cell.trim());
+}
+function parseListFileArg(path, maxRows) {
+  if (typeof path !== "string" || path.length === 0) {
+    return void 0;
+  }
+  const raw = readFileSync(path, "utf8");
+  const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (lines.length < 2) {
+    failWriteValidation(`${path} needs a header row and at least one data row`);
+  }
+  const columns = parseCsvLine(lines[0]).map((column) => column.trim());
+  const rows = [];
+  const emailPreviews = [];
+  const emailColumn = columns.findIndex((column) => listColumnField(column) === "email");
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    const row = {};
+    columns.forEach((column, index) => {
+      const value = cells[index] ?? "";
+      if (!value) {
+        return;
+      }
+      row[column] = listColumnField(column) === "email" ? sha256Lower(value) : value;
+    });
+    if (Object.keys(row).length > 0) {
+      rows.push(row);
+      emailPreviews.push(emailPreview(emailColumn >= 0 ? cells[emailColumn] ?? "" : ""));
+    }
+  }
+  if (rows.length > maxRows) {
+    failWriteValidation(`${path} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+  }
+  return { columns, rows, ...emailColumn >= 0 ? { emailPreviews } : {} };
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; "),
+      fields,
+      fix: capabilityFix("linkedin-ads")
+    }
+  });
+  process.exit(1);
+}
+var BATCH_NUDGE = "This command takes several ids at once \u2014 pass them comma-separated or with --ids-file instead of one call per id.";
+function batchNudge(data) {
+  return data.sameKindStaged === void 0 ? [] : [BATCH_NUDGE];
+}
+async function stageOp(raw, hints) {
+  const preflight = linkedinDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage", {
+      chatId,
+      op: preflight.data
+    });
+    const allHints = [
+      ...batchNudge(response.data),
+      ...hints ?? [],
+      ...approvalHints(preflight.data, response.data),
+      ...await adCopyHints(preflight.data)
+    ];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+async function stageLinkedinOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageOp(rawOps[0], hints);
+    return;
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = linkedinDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      failPreflight(
+        preflight.error.issues.map((issue) => ({
+          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""}`,
+          message: issue.message
+        }))
+      );
+    }
+    ops.push(preflight.data);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage-batch", { chatId, ops });
+    const allHints = [...hints ?? [], ...await adCopyHints(ops)];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+async function stageStatusChange(input) {
+  const payload = input.kind === "creative.update" ? { intendedStatus: input.status } : { status: input.status };
+  await stageLinkedinOps(
+    input.targets.map((target) => ({ kind: input.kind, accountId: input.accountId, target, payload }))
+  );
+}
+function requireTarget(args, entity) {
+  const inverted = booleanWordPositionalError(args, entity);
+  if (inverted !== void 0) {
+    failWriteValidation(inverted);
+  }
+  const positionals = readPositionals(args);
+  const target = args.id ?? args.target ?? args.ref ?? positionals[0];
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} id or URN as the positional argument`);
+  }
+  if (positionals.length > 1 || splitIdList(target).length > 1) {
+    failWriteValidation(
+      `this command takes one ${entity} id \u2014 run it once per id. Only pause/resume/archive/delete and 'creatives update' accept several ids in one call.`
+    );
+  }
+  return target;
+}
+function readPositionals(args) {
+  if (!Array.isArray(args._)) {
+    return [];
+  }
+  return args._.filter((value) => typeof value === "string" && value.length > 0);
+}
+function splitIdList(raw) {
+  return raw.split(",").map((id) => id.trim()).filter(Boolean);
+}
+function idsFileEntries(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return [];
+  }
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+}
+function requireTargets(args, entity) {
+  const positionals = readPositionals(args);
+  const named = [args.id, args.target, args.ref].filter(
+    (value) => typeof value === "string" && value.length > 0
+  );
+  const fromArgs = positionals.length > 0 ? positionals : named;
+  const targets = [.../* @__PURE__ */ new Set([...fromArgs.flatMap(splitIdList), ...idsFileEntries(args["ids-file"])])];
+  if (targets.length === 0) {
+    failWriteValidation(
+      `pass the ${entity} id or URN as the positional argument (comma-separated for several), or --ids-file <path>`
+    );
+  }
+  if (targets.length > LINKEDIN_DRAFT_BATCH_MAX) {
+    failWriteValidation(
+      `${targets.length} ids exceeds the batch limit of ${LINKEDIN_DRAFT_BATCH_MAX} \u2014 split the list`
+    );
+  }
+  return targets;
+}
+
+export {
+  TOTAL_BUDGET_HELP,
+  bareAccountId,
+  failWriteValidation,
+  loadJsonFileArg,
+  mergePayload,
+  loadPatchArg,
+  parseMoneyFlag,
+  parseDateFlag,
+  parseOnOffFlag,
+  parseLocaleFlag,
+  loadTargetingFileArg,
+  parseListFileArg,
+  stageOp,
+  stageLinkedinOps,
+  stageStatusChange,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-NOCMEK6R.js.map

package/dist/chunk-NQF5U6FX.js

@@ -0,0 +1,150 @@
+import {
+  GEO_TARGET_COUNTRIES,
+  LANGUAGE_CONSTANTS
+} from "./chunk-BNO3EFGR.js";
+
+// src/geo-context.ts
+function toOptions(names) {
+  return Object.entries(names).map(([id, name]) => ({ id, name })).sort((a, b) => a.name.localeCompare(b.name));
+}
+var GOOGLE_ADS_LOCATIONS = toOptions(GEO_TARGET_COUNTRIES);
+var GOOGLE_ADS_LANGUAGES = toOptions(LANGUAGE_CONSTANTS);
+var DATAFORSEO_LOCATIONS = [
+  { code: "us", name: "United States" },
+  { code: "uk", name: "United Kingdom" },
+  { code: "gb", name: "United Kingdom" },
+  { code: "ca", name: "Canada" },
+  { code: "au", name: "Australia" },
+  { code: "de", name: "Germany" },
+  { code: "fr", name: "France" },
+  { code: "es", name: "Spain" },
+  { code: "it", name: "Italy" },
+  { code: "br", name: "Brazil" },
+  { code: "mx", name: "Mexico" },
+  { code: "nl", name: "Netherlands" },
+  { code: "be", name: "Belgium" },
+  { code: "at", name: "Austria" },
+  { code: "ch", name: "Switzerland" },
+  { code: "pt", name: "Portugal" },
+  { code: "se", name: "Sweden" },
+  { code: "no", name: "Norway" },
+  { code: "dk", name: "Denmark" },
+  { code: "fi", name: "Finland" },
+  { code: "ie", name: "Ireland" },
+  { code: "nz", name: "New Zealand" },
+  { code: "in", name: "India" },
+  { code: "jp", name: "Japan" },
+  { code: "kr", name: "South Korea" },
+  { code: "sg", name: "Singapore" },
+  { code: "ar", name: "Argentina" },
+  { code: "cl", name: "Chile" },
+  { code: "co", name: "Colombia" },
+  { code: "pe", name: "Peru" },
+  { code: "pl", name: "Poland" },
+  { code: "cz", name: "Czech Republic" },
+  { code: "ro", name: "Romania" },
+  { code: "hu", name: "Hungary" },
+  { code: "za", name: "South Africa" },
+  { code: "il", name: "Israel" },
+  { code: "ae", name: "United Arab Emirates" },
+  { code: "sa", name: "Saudi Arabia" },
+  { code: "tr", name: "Turkey" },
+  { code: "ph", name: "Philippines" },
+  { code: "th", name: "Thailand" },
+  { code: "my", name: "Malaysia" },
+  { code: "id", name: "Indonesia" },
+  { code: "vn", name: "Vietnam" },
+  { code: "tw", name: "Taiwan" },
+  { code: "hk", name: "Hong Kong" }
+];
+var DATAFORSEO_LANGUAGES = [
+  { code: "en", name: "English" },
+  { code: "es", name: "Spanish" },
+  { code: "fr", name: "French" },
+  { code: "de", name: "German" },
+  { code: "it", name: "Italian" },
+  { code: "pt", name: "Portuguese" },
+  { code: "nl", name: "Dutch" },
+  { code: "ja", name: "Japanese" },
+  { code: "ko", name: "Korean" },
+  { code: "zh", name: "Chinese" },
+  { code: "ar", name: "Arabic" },
+  { code: "ru", name: "Russian" },
+  { code: "pl", name: "Polish" },
+  { code: "tr", name: "Turkish" },
+  { code: "sv", name: "Swedish" },
+  { code: "no", name: "Norwegian" },
+  { code: "da", name: "Danish" },
+  { code: "fi", name: "Finnish" }
+];
+function toRecord(list) {
+  const map = {};
+  for (const item of list) {
+    const key = item.id ?? item.code;
+    if (key) map[key] = item.name;
+  }
+  return map;
+}
+var researchLocationMap = toRecord(DATAFORSEO_LOCATIONS);
+var researchLanguageMap = toRecord(DATAFORSEO_LANGUAGES);
+function buildAdsQueryContext(locationArg, languageArg) {
+  const locationId = locationArg ?? "2840";
+  const languageId = languageArg ?? "1000";
+  const locationIsDefault = !locationArg;
+  const languageIsDefault = !languageArg;
+  const locationName = GEO_TARGET_COUNTRIES[locationId] ?? `ID ${locationId}`;
+  const languageName = LANGUAGE_CONSTANTS[languageId] ?? `ID ${languageId}`;
+  const ctx = {
+    location: `${locationName} (${locationId})`,
+    language: `${languageName} (${languageId})`,
+    location_is_default: locationIsDefault,
+    language_is_default: languageIsDefault
+  };
+  if (locationIsDefault || languageIsDefault) {
+    const parts = [];
+    if (locationIsDefault) parts.push("--location");
+    if (languageIsDefault) parts.push("--language");
+    ctx.defaults_warning = `Location and/or language were not specified \u2014 using defaults. Results are for ${locationName} in ${languageName}. Pass ${parts.join(" and ")} to target a different market.`;
+  }
+  return ctx;
+}
+function buildResearchQueryContext(locationArg, languageArg, options) {
+  const skipLocation = options?.skipLocation ?? false;
+  const locationCode = locationArg ?? "us";
+  const languageCode = languageArg ?? "en";
+  const locationIsDefault = !locationArg && !skipLocation;
+  const languageIsDefault = !languageArg;
+  const locationName = researchLocationMap[locationCode.toLowerCase()] ?? `code ${locationCode}`;
+  const languageName = researchLanguageMap[languageCode.toLowerCase()] ?? `code ${languageCode}`;
+  const ctx = {
+    location: skipLocation ? "N/A" : `${locationName} (${locationCode})`,
+    language: `${languageName} (${languageCode})`,
+    location_is_default: locationIsDefault,
+    language_is_default: languageIsDefault
+  };
+  const defaultParts = [];
+  if (locationIsDefault) defaultParts.push("--location");
+  if (languageIsDefault) defaultParts.push("--language");
+  if (defaultParts.length > 0) {
+    const market = skipLocation ? `${languageName}` : `${locationName} in ${languageName}`;
+    ctx.defaults_warning = `Location and/or language were not specified \u2014 using defaults. Results are for ${market}. Pass ${defaultParts.join(" and ")} to target a different market.`;
+  }
+  return ctx;
+}
+function warnDefaults(ctx) {
+  if (ctx.defaults_warning) {
+    process.stderr.write(`
+[WARNING] ${ctx.defaults_warning}
+
+`);
+  }
+}
+
+export {
+  GOOGLE_ADS_LOCATIONS,
+  GOOGLE_ADS_LANGUAGES,
+  buildAdsQueryContext,
+  buildResearchQueryContext,
+  warnDefaults
+};
+//# sourceMappingURL=chunk-NQF5U6FX.js.map