@koda-sl/baker-cli 0.571.0 → 0.572.0-dev.61ba69c66

package/dist/chunk-HKKHOMEQ.js

@@ -0,0 +1,180 @@
+import {
+  SAME_CLAIM_HELD,
+  TELL_QUESTIONS,
+  sameClaimQuestion,
+  tellQuestionsFor
+} from "./chunk-55AX6DOP.js";
+import {
+  HEADLINE_SET_FLOOR,
+  copySentences
+} from "./chunk-MX5NQAK6.js";
+import {
+  rememberedJev
+} from "./chunk-VCDFBFPT.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-Q4O7ICAK.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-4CYB33V3.js";
+import {
+  CAPABILITY_SURFACE_SPECS,
+  describeOpPayload
+} from "./chunk-R7XDGNZD.js";
+
+// src/commands/capabilities/fix.ts
+function capabilityFix(surface) {
+  const spec = CAPABILITY_SURFACE_SPECS[surface];
+  return {
+    action: `baker capabilities ${surface}`,
+    explanation: `Do not guess another field name. \`baker capabilities ${surface}\` lists every ${spec.label} change with its required and optional fields and the exact values each field accepts, plus what cannot be changed here at all and why. Read it, then either re-stage correctly or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+function payloadFix(surface, union, op) {
+  const kind = typeof op === "object" && op !== null ? op.kind : void 0;
+  const shape = typeof kind === "string" ? describeOpPayload(union, kind) : void 0;
+  if (typeof kind !== "string" || shape === void 0) return capabilityFix(surface);
+  return {
+    action: "restage_with_the_listed_fields",
+    explanation: `${kind} takes this payload (a field marked ? may be left out; a quoted value is the only one it accepts):
+${shape}
+Do not guess another field name: re-stage with these fields, or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+
+// src/commands/ads/boolean-word-positional.ts
+var BOOLEAN_WORD = /^(true|false)$/i;
+function booleanWordPositionalError(args, entity) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const word = positionals.find((value2) => typeof value2 === "string" && BOOLEAN_WORD.test(value2));
+  if (word === void 0) {
+    return void 0;
+  }
+  const value = word.toLowerCase();
+  const raised = Object.keys(args).filter((key) => key !== "_" && args[key] === true);
+  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(" or ") : "a boolean flag";
+  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(" or ") : `--<flag>=${value}`;
+  const negated = raised.length === 1 && value === "false" ? ` (or --no-${raised[0]})` : "";
+  return `"${word}" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped \u2014 attach it instead: ${fix}${negated}.`;
+}
+
+// src/commands/ads/copy-hints.ts
+import path from "path";
+
+// src/engine/copy-tells/judge.ts
+var SAMPLE_MAX = 60;
+var sample = (text) => text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}\u2026`;
+async function judgedCopyTells(input, ask) {
+  const sentences = input.texts.flatMap((t) => copySentences(t));
+  const pairs = (input.headlineSets ?? []).map((set) => set.map((h) => h.trim()).filter(Boolean)).filter((set) => set.length >= HEADLINE_SET_FLOOR).flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));
+  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];
+  if (questions.length === 0) return [];
+  const answers = await ask(questions);
+  if (answers === null) return null;
+  const tells = [];
+  TELL_QUESTIONS.forEach((tell, t) => {
+    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);
+    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? "") });
+  });
+  const offset = sentences.length * TELL_QUESTIONS.length;
+  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);
+  for (const set of new Set(cycled.map((p) => p.set))) {
+    const inSet = cycled.filter((p) => p.set === set);
+    const { a, b } = inSet[0] ?? { a: "", b: "" };
+    tells.push({ id: "synonym-cycling", count: inSet.length, sample: sample(`"${a}" / "${b}"`) });
+  }
+  return tells;
+}
+
+// src/commands/ads/copy-hints.ts
+var COPY_KEYS = /* @__PURE__ */ new Set([
+  "headline",
+  "headlines",
+  "longheadline",
+  "longheadlines",
+  "shortheadline",
+  "shortheadlines",
+  "description",
+  "descriptions",
+  "primarytext",
+  "primarytexts",
+  "message",
+  "messages",
+  "commentary",
+  "body",
+  "bodies",
+  "text",
+  "calltoaction",
+  "linkdescription",
+  "sitelinktext",
+  "callout",
+  "callouts",
+  "introtext"
+]);
+var HEADLINE_SET_KEYS = /* @__PURE__ */ new Set(["headlines", "longheadlines", "shortheadlines"]);
+var MAX_HINTS = 5;
+var SYNONYM_PAIR_FLOOR = 2;
+function asStrings(value) {
+  const one = (v) => {
+    const text = typeof v === "string" ? v : v !== null && typeof v === "object" ? v.text : "";
+    return typeof text === "string" && text.trim() ? text : void 0;
+  };
+  const values = Array.isArray(value) ? value : [value];
+  return values.map(one).filter((v) => v !== void 0);
+}
+function collectCopy(value, depth = 0) {
+  const texts = [];
+  const headlineSets = [];
+  if (depth > 4 || value === null || typeof value !== "object") return { texts, headlineSets };
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = collectCopy(item, depth + 1);
+      texts.push(...nested.texts);
+      headlineSets.push(...nested.headlineSets);
+    }
+    return { texts, headlineSets };
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];
+    if (strings.length > 0) {
+      texts.push(...strings);
+      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);
+      continue;
+    }
+    const nested = collectCopy(raw, depth + 1);
+    texts.push(...nested.texts);
+    headlineSets.push(...nested.headlineSets);
+  }
+  return { texts, headlineSets };
+}
+function hintFor(tell) {
+  if (tell.id === "synonym-cycling") {
+    return `AI COPY TELL \u2014 ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;
+  }
+  return `AI COPY TELL (${tell.id}) \u2014 "${tell.sample}". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;
+}
+async function adCopyHints(payload, ask) {
+  const { texts, headlineSets } = collectCopy(payload);
+  if (texts.length === 0) return [];
+  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), "canvas", ".cache");
+  const spent = [];
+  const judged = await judgedCopyTells(
+    { texts: texts.flatMap((t) => t.split("\n")), headlineSets },
+    ask ?? rememberedJev(path.join(cacheDir, "copy-tells.json"), (u) => spent.push(u))
+  ).catch(() => null);
+  await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+  const cycled = (judged ?? []).filter((t) => t.id === "synonym-cycling" && t.count >= SYNONYM_PAIR_FLOOR).sort((a, b) => b.count - a.count).slice(0, 1);
+  const tells = [...cycled, ...(judged ?? []).filter((t) => t.id !== "synonym-cycling")];
+  tells.sort(
+    (a, b) => (b.id === "synonym-cycling" ? 1 : 0) - (a.id === "synonym-cycling" ? 1 : 0) || b.count - a.count
+  );
+  return tells.slice(0, MAX_HINTS).map(hintFor);
+}
+
+export {
+  payloadFix,
+  booleanWordPositionalError,
+  adCopyHints
+};
+//# sourceMappingURL=chunk-HKKHOMEQ.js.map

package/dist/chunk-HKKHOMEQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/capabilities/fix.ts","../src/commands/ads/boolean-word-positional.ts","../src/commands/ads/copy-hints.ts","../src/engine/copy-tells/judge.ts"],"sourcesContent":["import type { CapabilitySurfaceId } from \"@baker/api/capabilities\";\nimport { CAPABILITY_SURFACE_SPECS, describeOpPayload } from \"@baker/api/capabilities\";\n\n/**\n * A rejected change should say where the real contract is.\n *\n * The expensive version of \"this field is not valid\" is an agent trying four\n * spellings of a field that never existed, staging a bogus op, and cleaning it\n * up again — several turns, none of them work. The validation message already\n * names what was wrong with THIS attempt; this names the one call that lists\n * every field the change accepts and every value each one takes, so the next\n * attempt is informed rather than another guess.\n */\nexport function capabilityFix(surface: CapabilitySurfaceId): { action: string; explanation: string } {\n  const spec = CAPABILITY_SURFACE_SPECS[surface];\n  return {\n    action: `baker capabilities ${surface}`,\n    explanation:\n      `Do not guess another field name. \\`baker capabilities ${surface}\\` lists every ${spec.label} change with its ` +\n      \"required and optional fields and the exact values each field accepts, plus what cannot be changed here at all \" +\n      \"and why. Read it, then either re-stage correctly or tell the user this part is out of reach — and carry on \" +\n      \"with the rest of the job either way.\",\n  };\n}\n\n/**\n * The fix for one refused op: the payload its kind takes, inline. The validator already knows which\n * op it refused, so sending the agent to the whole surface's contract (tens of KB, every op) to read\n * one op's fields is the expensive version of this. A kind the contract does not hold falls back to\n * that pointer, since no one op's shape can answer it.\n */\nexport function payloadFix(\n  surface: CapabilitySurfaceId,\n  union: { options: readonly unknown[] },\n  op: unknown,\n): { action: string; explanation: string } {\n  const kind = typeof op === \"object\" && op !== null ? (op as { kind?: unknown }).kind : undefined;\n  const shape = typeof kind === \"string\" ? describeOpPayload(union, kind) : undefined;\n  if (typeof kind !== \"string\" || shape === undefined) return capabilityFix(surface);\n  return {\n    action: \"restage_with_the_listed_fields\",\n    explanation:\n      `${kind} takes this payload (a field marked ? may be left out; a quoted value is the only one it accepts):\\n${shape}\\n` +\n      \"Do not guess another field name: re-stage with these fields, or tell the user this part is out of reach — and \" +\n      \"carry on with the rest of the job either way.\",\n  };\n}\n","/**\n * `--flag false` — the natural way to type a negation — is a citty trap, not a typo we can honour:\n * a boolean flag written with a space parses as the flag set to **TRUE** plus a stray positional\n * nobody consumes. The word does the OPPOSITE of what was typed and nothing fails, because the\n * target still resolves and the command still reports \"staged\". No layer downstream can catch it —\n * an inverted boolean is a valid op — so it has to be caught where the positionals are read.\n *\n * This is the same rule on every ad surface (it is citty's parse, not a platform's), but each\n * surface owns its own error envelope, so this returns the message and the caller fails with it.\n */\n\nconst BOOLEAN_WORD = /^(true|false)$/i;\n\n/**\n * The refusal message for a bare `true`/`false` sitting in the positionals, or `undefined` when\n * there is none. `entity` is the surface's own noun for what the positional addresses (\"campaign\",\n * \"ad set\", …), so the message reads as that command's vocabulary.\n */\nexport function booleanWordPositionalError(args: Record<string, unknown>, entity: string): string | undefined {\n  const positionals = Array.isArray(args._) ? args._ : [];\n  const word = positionals.find((value): value is string => typeof value === \"string\" && BOOLEAN_WORD.test(value));\n  if (word === undefined) {\n    return undefined;\n  }\n  const value = word.toLowerCase();\n  // Every flag citty just set to true, so the fix is copy-pasteable. Which one the word was meant for\n  // is unknowable from parsed args — it need not even follow that flag on the command line — so with\n  // several raised we list them all rather than inventing a single culprit the user never typed.\n  const raised = Object.keys(args).filter((key) => key !== \"_\" && args[key] === true);\n  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(\" or \") : \"a boolean flag\";\n  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(\" or \") : `--<flag>=${value}`;\n  const negated = raised.length === 1 && value === \"false\" ? ` (or --no-${raised[0]})` : \"\";\n  return `\"${word}\" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped — attach it instead: ${fix}${negated}.`;\n}\n","/**\n * AI copy tells on staged ad copy → `hints[]`.\n *\n * Ad text is the surface where a tell costs real money and the one place we had\n * no copy check at all: staging validated character limits and policy, never\n * whether the words read like a model wrote them.\n *\n * ADVISORY BY CONSTRUCTION. These are hints, never errors — an ad refused over a\n * fallible prose heuristic costs more than a tell that ships, and the agent can\n * act on a hint in the same turn. Nothing here can fail a staged write.\n *\n * Thresholds differ from the landing gate on purpose. A landing needs a CLUSTER\n * before a tell means anything (`COPY_TELL_GATES`); a 30-character headline has\n * no room for a cluster, so one occurrence is the signal. The exclusion list\n * below is where most of the judgment lives.\n *\n * The tells that read the words are asked of the decision model, in whatever\n * language the ad is written; when it cannot answer, nothing is reported rather\n * than a guess.\n */\n\nimport path from \"node:path\";\nimport type { CopyTell } from \"../../engine/copy-tells/detect.ts\";\nimport { judgedCopyTells } from \"../../engine/copy-tells/judge.ts\";\nimport { type AskNouls, rememberedJev } from \"../../engine/lib/remembered-nouls.ts\";\nimport type { ReviewUsage } from \"../../engine/nodes/local/lib/render-review.ts\";\nimport { findWorkspaceRoot } from \"../canvas/normalize-paths.ts\";\nimport { holdUnbilledSpend } from \"../canvas/unbilled-spend.ts\";\n\n/*\n * The tells that are a shape (`structuralCopyTells`) do not apply to ad copy, and\n * none is hinted. Each is a real convention in this medium, so reporting it would\n * train the agent to ignore hints:\n *   - `title-case-heading` — English search ads are conventionally Title Case.\n *   - `staccato-drama` — \"Compara. Ahorra. Cambia.\" is ad rhythm, not drama.\n *   - `emoji` — deliberate and effective in Meta and LinkedIn primary text.\n *   - `curly-quote` — inserted automatically by every editor copy is pasted from.\n *   - `inline-header-list` — a markdown shape that ad fields cannot hold.\n */\n\n/**\n * Payload keys whose values are copy a human will read in the ad. Every platform\n * names its primary text differently in `@baker/api` — Meta stages it as\n * `message`, LinkedIn as `commentary` — so the concept appears here under each\n * of its contract names, not under one invented one.\n */\nconst COPY_KEYS = new Set([\n  \"headline\",\n  \"headlines\",\n  \"longheadline\",\n  \"longheadlines\",\n  \"shortheadline\",\n  \"shortheadlines\",\n  \"description\",\n  \"descriptions\",\n  \"primarytext\",\n  \"primarytexts\",\n  \"message\",\n  \"messages\",\n  \"commentary\",\n  \"body\",\n  \"bodies\",\n  \"text\",\n  \"calltoaction\",\n  \"linkdescription\",\n  \"sitelinktext\",\n  \"callout\",\n  \"callouts\",\n  \"introtext\",\n]);\n\n/** Keys holding a SET of headlines, where synonym cycling is meaningful. */\nconst HEADLINE_SET_KEYS = new Set([\"headlines\", \"longheadlines\", \"shortheadlines\"]);\n\n/**\n * At most this many hints, so copy advice never crowds out the staging result.\n *\n * Five, not three: a heavily model-written ad routinely carries six tells, and a\n * cap of three showed the agent half the diagnosis. Since it already has the copy\n * in front of it, fixing six constructions in one pass is cheaper than three\n * re-stagings that each reveal the next batch.\n */\nconst MAX_HINTS = 5;\n/** Two near-duplicate pairs; one pair in a 15-headline RSA is not a pattern. */\nconst SYNONYM_PAIR_FLOOR = 2;\n\n/**\n * The copy under a copy key, whether it is a plain string or a Google text\n * asset. Google stages EVERY ad text as `{ text, pinnedField? }`\n * (`adTextAssetSchema` in `@baker/api/ads-google`), so reading only strings here\n * would skip the whole Google surface — headlines, descriptions, long headline.\n */\nfunction asStrings(value: unknown): string[] {\n  const one = (v: unknown): string | undefined => {\n    const text = typeof v === \"string\" ? v : v !== null && typeof v === \"object\" ? (v as { text?: unknown }).text : \"\";\n    return typeof text === \"string\" && text.trim() ? text : undefined;\n  };\n  const values = Array.isArray(value) ? value : [value];\n  return values.map(one).filter((v): v is string => v !== undefined);\n}\n\n/** Walk a staged-op payload of unknown shape and pull out the human-readable\n * copy fields plus any headline sets. Depth-limited — payloads are shallow, and\n * an unbounded walk on a hostile shape is a hang, not a hint. */\nfunction collectCopy(value: unknown, depth = 0): { texts: string[]; headlineSets: string[][] } {\n  const texts: string[] = [];\n  const headlineSets: string[][] = [];\n  if (depth > 4 || value === null || typeof value !== \"object\") return { texts, headlineSets };\n\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      const nested = collectCopy(item, depth + 1);\n      texts.push(...nested.texts);\n      headlineSets.push(...nested.headlineSets);\n    }\n    return { texts, headlineSets };\n  }\n\n  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {\n    const normalized = key.toLowerCase().replace(/[_-]/g, \"\");\n    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];\n    if (strings.length > 0) {\n      texts.push(...strings);\n      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);\n      continue;\n    }\n    // A copy key holding neither a string nor a text asset (`call_to_action`)\n    // still gets walked — a matched key must never swallow the subtree.\n    const nested = collectCopy(raw, depth + 1);\n    texts.push(...nested.texts);\n    headlineSets.push(...nested.headlineSets);\n  }\n  return { texts, headlineSets };\n}\n\nfunction hintFor(tell: CopyTell): string {\n  if (tell.id === \"synonym-cycling\") {\n    return `AI COPY TELL — ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;\n  }\n  return `AI COPY TELL (${tell.id}) — \"${tell.sample}\". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;\n}\n\n/**\n * Inspect a staged ad-copy payload and return advisory hints about AI writing\n * tells. Never throws; returns `[]` when the copy reads clean or the payload\n * carries no copy at all. `ask` is the decision model (the real one, its answers\n * kept in the workspace's canvas cache and its spend billed with the next run,\n * unless given).\n */\nexport async function adCopyHints(payload: unknown, ask?: AskNouls): Promise<string[]> {\n  const { texts, headlineSets } = collectCopy(payload);\n  if (texts.length === 0) return [];\n\n  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), \"canvas\", \".cache\");\n  const spent: ReviewUsage[] = [];\n  // A line break in ad text is the author's, never a wrap: each line is read on its own.\n  const judged = await judgedCopyTells(\n    { texts: texts.flatMap((t) => t.split(\"\\n\")), headlineSets },\n    ask ?? rememberedJev(path.join(cacheDir, \"copy-tells.json\"), (u) => spent.push(u)),\n  ).catch(() => null);\n  await holdUnbilledSpend(cacheDir, spent).catch(() => undefined);\n\n  // The floor is per headline set (one per ad); only the most cycled set is hinted.\n  const cycled = (judged ?? [])\n    .filter((t) => t.id === \"synonym-cycling\" && t.count >= SYNONYM_PAIR_FLOOR)\n    .sort((a, b) => b.count - a.count)\n    .slice(0, 1);\n  const tells: CopyTell[] = [...cycled, ...(judged ?? []).filter((t) => t.id !== \"synonym-cycling\")];\n\n  // Loudest first: the cycled-headline finding is a set-level defect, and the\n  // rest sort by how often the tell fired.\n  tells.sort(\n    (a, b) => (b.id === \"synonym-cycling\" ? 1 : 0) - (a.id === \"synonym-cycling\" ? 1 : 0) || b.count - a.count,\n  );\n  return tells.slice(0, MAX_HINTS).map(hintFor);\n}\n","/**\n * The AI copy tells in a piece of copy that are a reading of its words, and synonym cycling in a\n * set of headlines, asked of the decision model (Jev) in one fanned-out set of requests, in\n * whatever language the copy is written. Raw counts, like `structuralCopyTells`: the caller gates.\n */\nimport type { AskNouls } from \"../lib/remembered-nouls.ts\";\nimport type { CopyTell } from \"./detect.ts\";\nimport { HEADLINE_SET_FLOOR } from \"./patterns.ts\";\nimport { SAME_CLAIM_HELD, sameClaimQuestion, TELL_QUESTIONS, tellQuestionsFor } from \"./questions.ts\";\nimport { copySentences } from \"./sentences.ts\";\n\nconst SAMPLE_MAX = 60;\nconst sample = (text: string) => (text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}…`);\n\n/**\n * Every judged tell in `texts` (one count per sentence that carries it) and, for each headline set\n * of at least `HEADLINE_SET_FLOOR`, one `synonym-cycling` tell counting that set's pairs that are\n * one claim reworded. Null when the model could not answer: the caller reports nothing rather than\n * guess.\n */\nexport async function judgedCopyTells(\n  input: { texts: readonly string[]; headlineSets?: ReadonlyArray<readonly string[]> },\n  ask: AskNouls,\n): Promise<CopyTell[] | null> {\n  const sentences = input.texts.flatMap((t) => copySentences(t));\n  const pairs = (input.headlineSets ?? [])\n    .map((set) => set.map((h) => h.trim()).filter(Boolean))\n    .filter((set) => set.length >= HEADLINE_SET_FLOOR)\n    .flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));\n  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];\n  if (questions.length === 0) return [];\n  const answers = await ask(questions);\n  if (answers === null) return null;\n\n  const tells: CopyTell[] = [];\n  TELL_QUESTIONS.forEach((tell, t) => {\n    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);\n    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? \"\") });\n  });\n  const offset = sentences.length * TELL_QUESTIONS.length;\n  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);\n  for (const set of new Set(cycled.map((p) => p.set))) {\n    const inSet = cycled.filter((p) => p.set === set);\n    const { a, b } = inSet[0] ?? { a: \"\", b: \"\" };\n    tells.push({ id: \"synonym-cycling\", count: inSet.length, sample: sample(`\"${a}\" / \"${b}\"`) });\n  }\n  return tells;\n}\n"],"mappings":"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","names":["value"]}