@koda-sl/baker-cli 0.523.0 → 0.524.0-dev.3eb5500a1

package/dist/chunk-D4U72EIE.js

@@ -0,0 +1,638 @@
+import {
+  AD_PLATFORMS
+} from "./chunk-F3CZFUXZ.js";
+import {
+  staticFormatPatternSchema
+} from "./chunk-L55PHMSR.js";
+
+// src/engine/creative-rules/schema.ts
+import { z } from "zod";
+var RULE_STRENGTHS = ["never", "must", "prefer"];
+var RULE_APPLIES = ["copy", "picture", "cast", "logo", "voice", "sound", "subtitles", "any"];
+var RULE_KINDS = ["static", "video"];
+var RULE_SOURCE_KINDS = ["feedback", "user", "brand-import", "brand"];
+var phrase = z.string().trim().min(1).max(120);
+var Phrases = z.array(z.unknown()).transform((list) => list.flatMap((p) => phrase.safeParse(p).success ? [String(p).trim()] : []));
+
+// src/engine/copy-tells/rule-tells.ts
+var SOFT = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  ";",
+  ":",
+  "!",
+  "?",
+  "\xA1",
+  "\xBF",
+  '"',
+  "'",
+  "\u201C",
+  "\u201D",
+  "\u2018",
+  "\u2019",
+  "\xAB",
+  "\xBB",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  "\u2026",
+  "-",
+  "/",
+  "*",
+  "_"
+]);
+function fold(text2, keepCase) {
+  const plain = text2.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "").replace(/ß/g, "ss").replace(/ẞ/g, "SS");
+  return keepCase ? plain : plain.toLowerCase();
+}
+function tokens(text2, keepCase, marks = false) {
+  const all = fold(text2, keepCase).match(/[\p{L}\p{N}]+|[^\s\p{L}\p{N}]/gu) ?? [];
+  return marks ? all : all.filter((t) => !SOFT.has(t));
+}
+function onlyMarks(phrase2, keepCase) {
+  return tokens(phrase2, keepCase).length === 0 && tokens(phrase2, keepCase, true).length > 0;
+}
+function positions(words, phrase2) {
+  if (phrase2.length === 0) return [];
+  const at = [];
+  for (let i = 0; i + phrase2.length <= words.length; i++) {
+    if (phrase2.every((w, j) => words[i + j] === w)) at.push(i);
+  }
+  return at;
+}
+function aboutCase(check) {
+  const phrases = [...check.forbid ?? [], ...check.allow ?? [], ...check.require ?? []];
+  return phrases.some(
+    (a, i) => phrases.some((b, j) => i !== j && a !== b && fold(a, false) === fold(b, false) && fold(a, true) !== fold(b, true))
+  );
+}
+function sameLanguage(rule, language) {
+  const ruleLanguage = rule.scope.language;
+  if (!ruleLanguage) return true;
+  if (!language) return false;
+  const primary = (tag) => tag.toLowerCase().split(/[-_]/)[0];
+  return primary(ruleLanguage) === primary(language);
+}
+function forbiddenIn(line, check, keepCase) {
+  for (const banned of check.forbid ?? []) {
+    const marks = onlyMarks(banned, keepCase);
+    const words = tokens(line, keepCase, marks);
+    const allowed = (check.allow ?? []).flatMap((a) => {
+      const allow = tokens(a, keepCase, marks);
+      return positions(words, allow).map((start) => [start, start + allow.length]);
+    });
+    const phrase2 = tokens(banned, keepCase, marks);
+    const free = positions(words, phrase2).some(
+      (start) => !allowed.some(([from, to]) => start >= from && start + phrase2.length <= to)
+    );
+    if (free) return banned;
+  }
+  return null;
+}
+function tellsOf(rule, lines) {
+  const check = rule.check;
+  if (!check) return [];
+  const keepCase = aboutCase(check);
+  const base = {
+    rule: rule.id,
+    strength: rule.strength,
+    text: rule.text,
+    ...rule.source.quote ? { quote: rule.source.quote } : {}
+  };
+  const forbidden = lines.flatMap((line) => {
+    const phrase2 = forbiddenIn(line, check, keepCase);
+    return phrase2 ? [{ ...base, kind: "forbidden", phrase: phrase2, line }] : [];
+  });
+  const missing = (check.require ?? []).flatMap((required) => {
+    const marks = onlyMarks(required, keepCase);
+    const phrase2 = tokens(required, keepCase, marks);
+    const said = lines.some((line) => positions(tokens(line, keepCase, marks), phrase2).length > 0);
+    return said ? [] : [{ ...base, kind: "missing", phrase: required }];
+  });
+  return [...forbidden, ...missing];
+}
+function ruleTells(lines, rules, language) {
+  return rules.filter((rule) => rule.strength !== "prefer" && sameLanguage(rule, language)).flatMap((rule) => tellsOf(rule, lines));
+}
+
+// src/commands/creatives/ideas-model.ts
+import { parse as parseYaml, YAMLParseError } from "yaml";
+var IDEA_ANGLES = [
+  "pain_relief",
+  "aspiration",
+  "status",
+  "fear",
+  "FOMO",
+  "identity",
+  "contrarian",
+  "education",
+  "novelty",
+  "authority",
+  "community",
+  "transformation",
+  "convenience",
+  "save_money",
+  "save_time",
+  "save_effort",
+  "named_enemy",
+  "objection_crusher",
+  "villain_democratization",
+  "commiseration",
+  "recognition_mirror",
+  "flipped_idiom"
+];
+var IDEA_VIDEO_FORMATS = [
+  "video_ugc",
+  "video_founder",
+  "video_testimonial",
+  "video_demo",
+  "video_screen_recording",
+  "video_explainer",
+  "video_motion_graphics"
+];
+var IDEA_FORMATS = [...staticFormatPatternSchema.options, ...IDEA_VIDEO_FORMATS];
+var AWARENESS_STAGES = ["unaware", "problem_aware", "solution_aware", "product_aware", "most_aware"];
+var EVIDENCE_LEVELS = ["observed", "interpreted", "hypothesized", "generated"];
+var IDEA_STATUSES = ["idea", "built", "testing", "winner", "failed", "inconclusive", "retired"];
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
+function frontmatterOf(markdown) {
+  const block = FRONTMATTER.exec(markdown)?.[1];
+  if (block === void 0) return null;
+  try {
+    const parsed = parseYaml(block);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function frontmatterError(markdown) {
+  const block = FRONTMATTER.exec(markdown)?.[1];
+  if (block === void 0) return null;
+  try {
+    parseYaml(block);
+    return null;
+  } catch (e) {
+    const line = e instanceof YAMLParseError ? e.linePos?.[0]?.line : void 0;
+    const at = line ? ` at line ${line} (\`${block.split(/\r?\n/)[line - 1]?.trim() ?? ""}\`)` : "";
+    return `the frontmatter is not valid YAML${at}: put each text value wholly in double quotes, with any quote inside it as \\" or as single quotes`;
+  }
+}
+function text(value) {
+  if (typeof value === "string") return value.trim() || void 0;
+  if (typeof value === "number") return String(value);
+  return void 0;
+}
+function oneOf(values, value) {
+  return typeof value === "string" && values.includes(value) ? value : void 0;
+}
+var CHECKABLE_SOURCE = /^(?:https?:\/\/\S+|[a-z_]+:[\w-]+)$/i;
+function evidenceStatus(stated, source) {
+  if (stated !== "observed") return stated;
+  return CHECKABLE_SOURCE.test(source) ? "observed" : "interpreted";
+}
+function parseInsight(id, markdown) {
+  const fm = frontmatterOf(markdown);
+  const quote = text(fm?.quote);
+  const source = text(fm?.source);
+  if (!fm || !quote || !source) return null;
+  const force = text(fm.force);
+  const persona = text(fm.persona);
+  const sourceKind = text(fm.sourceKind);
+  const author = markdown.replace(/^---[\s\S]*?\n---/, "").match(/\bby ([\p{Lu}][\p{L}'’-]*\.?(?: [\p{Lu}][\p{L}'’-]*\.?)?)/u)?.[1]?.replace(new RegExp("(\\p{L}{2,})\\.$", "u"), "$1");
+  return {
+    id,
+    type: text(fm.type) ?? "other",
+    quote,
+    source,
+    status: evidenceStatus(oneOf(EVIDENCE_LEVELS, fm.status) ?? "observed", source),
+    ...sourceKind ? { sourceKind } : {},
+    ...force ? { force } : {},
+    ...persona ? { persona } : {},
+    ...author ? { author } : {}
+  };
+}
+function evidenceList(value) {
+  if (Array.isArray(value)) return value.flatMap((e) => text(e) ? [String(text(e))] : []);
+  const single = text(value);
+  return single ? [single] : [];
+}
+function fieldProblems(f) {
+  const problems = [];
+  if (!f.who) problems.push("who is missing: the persona it is for");
+  if (!f.message)
+    problems.push(
+      "message is missing: the one promise a stranger should get, what is offered and what changes for them"
+    );
+  if (!f.why) problems.push("why is missing: the brief finding it answers");
+  if (!f.awareness) {
+    const written = f.awarenessWritten ? `"${f.awarenessWritten}" ` : "";
+    problems.push(`awareness ${written}must be one of ${AWARENESS_STAGES.join(", ")}`);
+  }
+  if (!(f.angle && IDEA_ANGLES.includes(f.angle)))
+    problems.push(`angle ${f.angle ? `"${f.angle}" ` : ""}must be one of ${IDEA_ANGLES.join(", ")}`);
+  if (f.format && !IDEA_FORMATS.includes(f.format))
+    problems.push(`format "${f.format}" must be one of ${IDEA_FORMATS.join(", ")}`);
+  if (!f.format && !f.shows)
+    problems.push(
+      "shows is missing: what the scroller sees in the first second that makes the message land (a before/after, a reaction, the product doing it, a real review, the pain itself); the proven ad is searched by it"
+    );
+  return [...problems, ...platformProblems(f.platforms)];
+}
+function platformProblems(platforms) {
+  const unknown = (platforms ?? []).filter((p) => !AD_PLATFORMS.includes(p));
+  return unknown.length > 0 ? [`platforms ${unknown.map((p) => `"${p}"`).join(", ")} must be among ${AD_PLATFORMS.join(", ")}`] : [];
+}
+function platformList(value) {
+  const list = (Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value]).map((v) => text(v)).filter((v) => v !== void 0);
+  return list.length > 0 ? list : void 0;
+}
+function parseIdea(id, markdown) {
+  const unparsable = frontmatterError(markdown);
+  if (unparsable) return { problems: [unparsable] };
+  const fm = frontmatterOf(markdown) ?? {};
+  const f = {
+    who: text(fm.who),
+    message: text(fm.message),
+    why: text(fm.why),
+    angle: text(fm.angle),
+    shows: text(fm.shows),
+    format: text(fm.format),
+    awareness: oneOf(AWARENESS_STAGES, fm.awareness),
+    awarenessWritten: text(fm.awareness),
+    platforms: platformList(fm.platforms)
+  };
+  const problems = fieldProblems(f);
+  const { who, message, why, angle, shows, format, awareness } = f;
+  if (problems.length > 0 || !who || !message || !why || !awareness || !angle) return { problems };
+  const product = text(fm.product);
+  return {
+    idea: {
+      id,
+      who,
+      message,
+      evidence: evidenceList(fm.evidence),
+      awareness,
+      angle,
+      ...shows ? { shows } : {},
+      ...format ? { format } : {},
+      job: fm.job === "closer" ? "closer" : "opener",
+      why,
+      status: oneOf(IDEA_STATUSES, fm.status) ?? "idea",
+      ...product ? { product } : {},
+      ...f.platforms ? { platforms: f.platforms } : {}
+    },
+    problems
+  };
+}
+var EVIDENCE_WEIGHT = {
+  observed: 3,
+  interpreted: 2,
+  hypothesized: 1,
+  generated: 0,
+  explore: 0
+};
+var LIVE_STATUSES = ["built", "testing", "winner"];
+function claimsOf(message) {
+  return [...message.matchAll(/\d[\d.,]*\s?(?:%|€|\$|£|x\b|k\b)?/gi)].map((m) => m[0].trim());
+}
+function figureOf(claim) {
+  return claim.replace(/[^\d]/g, "");
+}
+function figuresIn(text2) {
+  return new Set([...text2.matchAll(/\d(?:[\d.,]*\d)?/g)].map((m) => figureOf(m[0])));
+}
+function normalize(value) {
+  return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function pictureOf(idea) {
+  return idea.format ?? normalize(idea.shows ?? "");
+}
+function sentencesOf(message) {
+  return message.split(/[.!?]+(?:\s|$)/).filter((s) => s.trim().length > 0).length;
+}
+var SAME_WORDS = (a, b) => normalize(a) === normalize(b);
+function repeatedFailure(idea, failed, sameMessage) {
+  const lost = failed.find(
+    (f) => f.id !== idea.id && (sameMessage(f.message, idea.message) || f.angle === idea.angle && pictureOf(f) === pictureOf(idea))
+  );
+  return lost ? [`says what "${lost.id}" said, and that idea failed in the account: change the message, not just the picture`] : [];
+}
+function likelyMeant(id, insights) {
+  const words = (text2) => new Set(
+    text2.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((w) => w.length >= 3)
+  );
+  const wanted = words(id);
+  let best;
+  for (const insight of insights.values()) {
+    const said = words(`${insight.id} ${insight.quote}`);
+    const shared = [...wanted].filter((w) => said.has(w)).length;
+    if (shared > 0 && shared > (best?.shared ?? 0)) best = { id: insight.id, shared };
+  }
+  return best?.id;
+}
+function backingOf(idea, insights, problems) {
+  const backing = idea.evidence.flatMap((id) => {
+    const insight = insights.get(id);
+    if (!insight) {
+      const meant = likelyMeant(id, insights);
+      problems.push(
+        `evidence "${id}" is not in src/content/insights/: ${meant ? `did you mean "${meant}"? ` : ""}name an insight on file by its id, or leave it out`
+      );
+    }
+    return insight ? [insight] : [];
+  });
+  return [...backing].sort((a, b) => EVIDENCE_WEIGHT[b.status] - EVIDENCE_WEIGHT[a.status])[0];
+}
+function unsourcedClaims(text2, corpusFigures) {
+  return claimsOf(text2).filter((claim) => {
+    const figure = figureOf(claim);
+    return figure !== "" && !corpusFigures.has(figure);
+  });
+}
+function productProblems(idea, ctx) {
+  const read = idea.product ? ctx.products.get(idea.product) : void 0;
+  const unread = idea.product && (!read || "error" in read) ? [
+    `product "${idea.product}" is not a product of the connected store${read && "error" in read ? ` (${read.error})` : ""}: name it by the handle \`baker shopify products --search\` gives, or remove product`
+  ] : [];
+  const figures = read && "record" in read ? /* @__PURE__ */ new Set([...ctx.corpusFigures, ...figuresIn(read.record)]) : ctx.corpusFigures;
+  return [...unread, ...claimProblems(idea.message, { ...ctx, corpusFigures: figures })];
+}
+function whyNotBacking(insight) {
+  const named = `the insight "${insight.id}"`;
+  if (fromMarket(insight))
+    return `${named}, what someone in the market said, not our customer: it is never our claim; drop it`;
+  if (insight.status === "hypothesized" || insight.status === "generated")
+    return `${named}, a ${insight.status} reading, not a customer's words: source it or drop it`;
+  if (!CHECKABLE_SOURCE.test(insight.source))
+    return `${named}, which cites no link a reader can open (its source: "${insight.source}"): give it its link, or drop the figure`;
+  return `${named}, a statistic about people rather than a customer's words: it cannot stand behind our claim; drop it`;
+}
+function claimProblems(message, ctx) {
+  return unsourcedClaims(message, ctx.corpusFigures).map((claim) => {
+    const figure = figureOf(claim);
+    const holder = [...ctx.insights.values()].find((insight) => figuresIn(insight.quote).has(figure));
+    return holder ? `"${claim}" is in ${whyNotBacking(holder)}` : `"${claim}" is in no customer quote, COMPANY.md, Knowledge entry or store product the idea names: if it is a store product's price, name the product in the idea's \`product\` (its handle); otherwise drop it, or ask the user and record it in the Knowledge once they confirm it, citing them; never write it into the Knowledge or COMPANY.md yourself to pass this check`;
+  });
+}
+var MARKET_SOURCES = ["reddit", "forum", "web"];
+var TESTIMONIAL_FORMATS = ["review_screenshot", "testimonial_quote", "video_testimonial"];
+function fromMarket(insight) {
+  return insight?.sourceKind !== void 0 && MARKET_SOURCES.includes(insight.sourceKind);
+}
+function sourcesClaims(insight) {
+  return insight.status === "observed" && !fromMarket(insight);
+}
+function borrowedProof(idea, insights) {
+  return idea.evidence.find((id) => {
+    const insight = insights.get(id);
+    return fromMarket(insight) && insight?.type === "proof";
+  });
+}
+function fakeReviewProblem(idea, insights) {
+  if (!idea.format || !TESTIMONIAL_FORMATS.includes(idea.format)) return [];
+  const cited = idea.evidence.flatMap((id) => insights.get(id) ?? []);
+  if (cited.length === 0 || !cited.every(fromMarket)) return [];
+  return [
+    `${idea.format} needs a quote from our own customer (a review, testimonial, call or survey); every one cited was said by someone in the market. Pick another format, or cite our own customer`
+  ];
+}
+function warningsOf(idea, evidence, personas, insights) {
+  const warnings = [];
+  const video = IDEA_VIDEO_FORMATS.includes(idea.format ?? "");
+  if (idea.status === "idea" && !video && !idea.shows)
+    warnings.push(
+      "say what it shows (`shows`): what the scroller sees in the first second that lands the message; the proven ad is searched by it, and without it by what the company sells"
+    );
+  const borrowed = borrowedProof(idea, insights);
+  if (borrowed) {
+    warnings.push(
+      `"${borrowed}" was said by someone in the market, not a customer of ours: use their words for the problem, never show it as our review, testimonial or result`
+    );
+  }
+  if (sentencesOf(idea.message) > 1 || idea.message.split(/\s+/).length > 25) {
+    warnings.push(
+      'the message says more than one thing: keep one promise that still names what is offered ("a free roof survey that shows your real saving", never a slogan like "the numbers, explained"), the rest goes to the ad text'
+    );
+  }
+  if (personas.length > 0 && !personas.includes(idea.who)) {
+    warnings.push(`who "${idea.who}" is not a persona in the Knowledge (${personas.join(", ")})`);
+  }
+  if (evidence === "explore") {
+    warnings.push("no customer evidence: an explore bet. `baker research customers` may find some");
+  }
+  return warnings;
+}
+function checkOne(idea, ctx) {
+  const problems = [];
+  const best = backingOf(idea, ctx.insights, problems);
+  const evidence = best?.status ?? "explore";
+  problems.push(
+    ...productProblems(idea, ctx),
+    ...fakeReviewProblem(idea, ctx.insights),
+    ...ruleTells([idea.message], ctx.rules, ctx.language).filter((t) => t.kind === "forbidden").map((t) => `The message says "${t.phrase}": ${t.rule} (${t.strength}) \u2014 ${t.text}`)
+  );
+  const duplicate = ctx.duplicateOf.get(idea.id);
+  if (duplicate) {
+    problems.push(
+      `same angle and the same picture (format or what it shows), or the same message, as "${duplicate}": to the platform it is the same ad. Change the angle or what it shows`
+    );
+  }
+  const gaps = [];
+  if (!ctx.covered.has(idea.awareness)) gaps.push(`no live ad speaks to ${idea.awareness} people`);
+  if (idea.job === "closer" && ctx.closersLive === 0) gaps.push("no live ad closes warm people");
+  return {
+    id: idea.id,
+    status: idea.status,
+    message: idea.message,
+    evidence,
+    ...best ? { quote: best.quote } : {},
+    awareness: idea.awareness,
+    angle: idea.angle,
+    ...idea.shows ? { shows: idea.shows } : {},
+    ...idea.format ? { format: idea.format } : {},
+    ...idea.platforms ? { platforms: idea.platforms } : {},
+    problems,
+    warnings: [
+      ...warningsOf(idea, evidence, ctx.personas, ctx.insights),
+      ...repeatedFailure(idea, ctx.failed, ctx.sameMessage)
+    ],
+    gaps,
+    score: EVIDENCE_WEIGHT[evidence] + gaps.length - (problems.length > 0 ? 10 : 0)
+  };
+}
+function duplicatesOf(ideas, insights) {
+  const active = ideas.filter((i) => i.status !== "retired" && i.status !== "failed");
+  const strength = (idea) => Math.max(0, ...idea.evidence.map((id) => EVIDENCE_WEIGHT[insights.get(id)?.status ?? "explore"]));
+  const position = new Map(ideas.map((idea, index) => [idea.id, index]));
+  const order = [...active].sort(
+    (a, b) => Number(LIVE_STATUSES.includes(b.status)) - Number(LIVE_STATUSES.includes(a.status)) || strength(b) - strength(a) || (position.get(a.id) ?? 0) - (position.get(b.id) ?? 0)
+  );
+  const seenPairs = /* @__PURE__ */ new Map();
+  const seenMessages = /* @__PURE__ */ new Map();
+  const duplicateOf = /* @__PURE__ */ new Map();
+  for (const idea of order) {
+    const pair = `${idea.angle}\xD7${pictureOf(idea)}`;
+    const message = normalize(idea.message);
+    const earlier = seenPairs.get(pair) ?? seenMessages.get(message);
+    if (earlier) duplicateOf.set(idea.id, earlier);
+    if (!seenPairs.has(pair)) seenPairs.set(pair, idea.id);
+    if (!seenMessages.has(message)) seenMessages.set(message, idea.id);
+  }
+  return duplicateOf;
+}
+function checkIdeas(input) {
+  const insights = new Map(input.insights.map((insight) => [insight.id, insight]));
+  const ownQuotes = input.insights.filter(sourcesClaims).map((i) => i.quote);
+  const corpusFigures = figuresIn(`${input.knowledge}
+${ownQuotes.join("\n")}`);
+  const covered = new Set(input.coveredAwareness);
+  const duplicateOf = duplicatesOf(input.ideas, insights);
+  const checks = input.ideas.map(
+    (idea) => checkOne(idea, {
+      insights,
+      corpusFigures,
+      covered,
+      duplicateOf,
+      personas: input.personas,
+      closersLive: input.closersLive,
+      failed: input.ideas.filter((i) => i.status === "failed"),
+      sameMessage: input.sameMessage ?? SAME_WORDS,
+      products: input.products ?? /* @__PURE__ */ new Map(),
+      rules: input.rules ?? [],
+      language: input.language
+    })
+  );
+  const toBuild = (c) => c.status === "idea";
+  return checks.sort(
+    (a, b) => Number(toBuild(b)) - Number(toBuild(a)) || b.score - a.score || a.id.localeCompare(b.id)
+  );
+}
+
+// src/engine/creative-rules/read.ts
+import { createHash } from "crypto";
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { z as z2 } from "zod";
+var RULES_DIR = path.join("src", "content", "creative-rules");
+var optionalText = z2.string().trim().min(1).max(2e3).optional().catch(void 0);
+var optionalPhrases = Phrases.optional().catch(void 0);
+var dateText = z2.union([z2.string(), z2.date().transform((d) => d.toISOString().slice(0, 10))]).pipe(z2.string().trim().min(1)).optional().catch(void 0);
+var Frontmatter = z2.object({
+  strength: z2.enum(RULE_STRENGTHS).catch("must"),
+  applies: z2.enum(RULE_APPLIES).catch("any"),
+  scope: z2.object({
+    kinds: z2.array(z2.enum(RULE_KINDS)).optional().catch(void 0),
+    products: optionalPhrases,
+    platforms: optionalPhrases,
+    language: z2.string().trim().min(2).max(10).optional().catch(void 0)
+  }).catch({}),
+  check: z2.object({
+    forbid: optionalPhrases,
+    require: optionalPhrases,
+    allow: optionalPhrases,
+    people: z2.literal("real").optional().catch(void 0)
+  }).optional().catch(void 0),
+  source: z2.object({
+    kind: z2.enum(RULE_SOURCE_KINDS).catch("user"),
+    feedbackId: optionalText,
+    runId: optionalText,
+    slug: optionalText,
+    quote: optionalText,
+    date: dateText
+  }).catch({ kind: "user" }),
+  status: z2.enum(["active", "retired"]).catch("active"),
+  retiredBy: optionalText
+});
+function defined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, v]) => v !== void 0 && !(Array.isArray(v) && v.length === 0))
+  );
+}
+function bodyOf(markdown) {
+  const body = markdown.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").trim();
+  const paragraphs = body.split(/\r?\n\s*\r?\n/).map((p) => p.trim()).filter(Boolean);
+  const why = paragraphs.find((p) => /^(?:why|por qué|porque)\s*:/i.test(p));
+  const text2 = paragraphs.find((p) => p !== why && !p.startsWith("#"));
+  return { ...text2 ? { text: text2 } : {}, ...why ? { why: why.replace(/^[^:]+:\s*/, "") } : {} };
+}
+function parseRuleFile(id, markdown) {
+  const { text: text2, why } = bodyOf(markdown);
+  if (!text2) return null;
+  const fm = Frontmatter.parse(frontmatterOf(markdown) ?? {});
+  const check = fm.check ? defined(fm.check) : void 0;
+  return {
+    id,
+    origin: "learned",
+    strength: fm.strength,
+    applies: fm.applies,
+    scope: defined(fm.scope),
+    ...check && Object.keys(check).length > 0 ? { check } : {},
+    text: text2,
+    ...why ? { why } : {},
+    source: defined(fm.source),
+    status: fm.status,
+    ...fm.retiredBy ? { retiredBy: fm.retiredBy } : {}
+  };
+}
+async function readLearnedRules(root) {
+  const dir = path.join(root, RULES_DIR);
+  const files = (await readdir(dir).catch(() => [])).filter((f) => f.endsWith(".md")).sort();
+  const rules = await Promise.all(
+    files.map(
+      async (file) => parseRuleFile(file.replace(/\.md$/, ""), await readFile(path.join(dir, file), "utf8").catch(() => ""))
+    )
+  );
+  return rules.filter((r) => r !== null);
+}
+var declaredId = (text2) => `brand-${createHash("sha256").update(text2.trim()).digest("hex").slice(0, 8)}`;
+function shownBothWays(text2, phrase2, allow) {
+  const fold2 = (s) => s.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase();
+  const said = fold2(text2).split(fold2(phrase2)).length - 1;
+  return said > 1 && !(allow ?? []).some((a) => fold2(a).includes(fold2(phrase2)));
+}
+var BARE_SHORT_WORD = new RegExp("^\\p{L}{1,2}$", "u");
+function declaredRules(rules) {
+  return rules.map(({ text: text2, strength, applies, forbid, allow }) => {
+    const checked = forbid?.filter((p) => !BARE_SHORT_WORD.test(p.trim()) && !shownBothWays(text2, p, allow));
+    const check = defined({ forbid: checked, ...checked?.length ? { allow } : {} });
+    return {
+      id: declaredId(text2),
+      origin: "declared",
+      strength,
+      applies,
+      scope: {},
+      ...Object.keys(check).length > 0 ? { check } : {},
+      text: text2,
+      source: { kind: "brand" },
+      status: "active"
+    };
+  });
+}
+
+export {
+  RULE_STRENGTHS,
+  RULE_APPLIES,
+  RULE_KINDS,
+  Phrases,
+  ruleTells,
+  IDEA_ANGLES,
+  IDEA_VIDEO_FORMATS,
+  IDEA_FORMATS,
+  AWARENESS_STAGES,
+  frontmatterOf,
+  parseInsight,
+  parseIdea,
+  figuresIn,
+  SAME_WORDS,
+  unsourcedClaims,
+  sourcesClaims,
+  checkIdeas,
+  RULES_DIR,
+  parseRuleFile,
+  readLearnedRules,
+  declaredRules
+};
+//# sourceMappingURL=chunk-D4U72EIE.js.map