@sonordev/contracts 2.7.1 → 2.9.0

package/dist/business-claims.js

@@ -0,0 +1,1378 @@
+'use strict';
+
+// src/contracts/voice.ts
+var VOICE_MASK = "\u2800";
+var TABLE = [
+  ["do not", "don't"],
+  ["does not", "doesn't"],
+  ["did not", "didn't"],
+  ["is not", "isn't"],
+  ["are not", "aren't"],
+  ["was not", "wasn't"],
+  ["were not", "weren't"],
+  ["cannot", "can't"],
+  ["can not", "can't"],
+  ["will not", "won't"],
+  ["would not", "wouldn't"],
+  ["should not", "shouldn't"],
+  ["could not", "couldn't"],
+  ["has not", "hasn't"],
+  ["have not", "haven't"],
+  ["had not", "hadn't"],
+  ["must not", "mustn't"],
+  ["need not", "needn't"],
+  ["it is", "it's"],
+  ["that is", "that's"],
+  ["there is", "there's"],
+  ["here is", "here's"],
+  ["who is", "who's"],
+  ["what is", "what's"],
+  ["you are", "you're"],
+  ["we are", "we're"],
+  ["they are", "they're"],
+  ["I am", "I'm"],
+  ["you will", "you'll"],
+  ["we will", "we'll"],
+  ["they will", "they'll"],
+  ["it will", "it'll"],
+  ["we would", "we'd"],
+  ["you would", "you'd"],
+  ["they would", "they'd"],
+  ["let us", "let's"]
+];
+var PAIRS = TABLE.map(([full, contracted]) => ({
+  full,
+  contracted,
+  negation: / not$|^cannot$/.test(full),
+  pattern: new RegExp(`\\b${full.replace(/ /g, "[ \\t]+")}\\b`, "gi")
+}));
+var CAN_NOT_ONLY = /[ \t]+only\b/iy;
+var CLAUSE_END = /[ \t]*(?:[.,;:!?)\]}"\u201d\u2019\u2026\u2014\u2013-]|\r?\n|\r?$)/y;
+var CONJUNCTION = /[ \t]+(?:and|or|but|nor)\b/iy;
+var LET_US_SUGGESTIONS = /[ \t]+(?:look|start|begin|consider|turn|see|review|compare|break|dig|recap|unpack|explore|examine|revisit|focus|go|talk|move|get started|step back|zoom out)\b/iy;
+var PROSE_GAP = /[\s*_\u2800]/;
+var preserveCase = (match, replacement) => match[0] === match[0].toUpperCase() && match[0] !== match[0].toLowerCase() ? replacement[0].toUpperCase() + replacement.slice(1) : replacement;
+var maskAll = (text) => text.replace(/[^\r\n]/g, VOICE_MASK);
+function maskProtected(text, ranges) {
+  if (!ranges) return text;
+  if (!Array.isArray(ranges)) return maskAll(text);
+  if (ranges.length === 0) return text;
+  const length = text.length;
+  const edges = new Int32Array(length + 1);
+  let any = false;
+  for (const range of ranges) {
+    const from = range?.[0];
+    const to = range?.[1];
+    if (typeof from !== "number" || typeof to !== "number" || Number.isNaN(from) || Number.isNaN(to) || from > to) return maskAll(text);
+    const start = Math.max(0, Math.floor(from));
+    const end = Math.min(length, Math.ceil(to));
+    if (end <= start) continue;
+    edges[start] += 1;
+    edges[end] -= 1;
+    any = true;
+  }
+  if (!any) return text;
+  const parts = [];
+  let depth = 0;
+  let runStart = 0;
+  let runProtected = false;
+  for (let i = 0; i <= length; i++) {
+    const isProtected = i < length && (depth += edges[i]) > 0;
+    if (i === length || isProtected !== runProtected) {
+      if (i > runStart) parts.push(runProtected ? maskAll(text.slice(runStart, i)) : text.slice(runStart, i));
+      runStart = i;
+      runProtected = isProtected;
+    }
+  }
+  return parts.join("");
+}
+function walkBackOverGap(text, start) {
+  let at = start;
+  while (at > 0 && text[at - 1] !== "\n" && PROSE_GAP.test(text[at - 1])) at--;
+  return at;
+}
+function firstStop(text, from) {
+  for (let i = from; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code === 46 || code === 33 || code === 63 || code === 10) return i;
+  }
+  return text.length;
+}
+function mustStayFull(pair, text, titleLike, start, end, look) {
+  if (pair.full === "can not") {
+    CAN_NOT_ONLY.lastIndex = end;
+    return CAN_NOT_ONLY.test(text);
+  }
+  if (pair.negation) return false;
+  CLAUSE_END.lastIndex = end;
+  if (CLAUSE_END.test(text)) return true;
+  CONJUNCTION.lastIndex = end;
+  if (CONJUNCTION.test(text)) return true;
+  if (pair.full === "what is") {
+    if (look.stop < end) look.stop = firstStop(text, end);
+    if (text.charCodeAt(look.stop) === 63) return true;
+    if (titleLike) {
+      const at = walkBackOverGap(text, start);
+      if (at === 0 || text[at - 1] === "\n") return true;
+    }
+  }
+  if (pair.full === "let us") {
+    const at = walkBackOverGap(text, start);
+    if (at > 0 && !".!?:\n".includes(text[at - 1])) return true;
+    LET_US_SUGGESTIONS.lastIndex = end;
+    return !LET_US_SUGGESTIONS.test(text);
+  }
+  return false;
+}
+function scanUncontracted(text, masked, titleLike) {
+  if (masked.length < 4) return [];
+  const hits = [];
+  const claimed = new Uint8Array(masked.length);
+  for (const pair of PAIRS) {
+    const look = { stop: -1 };
+    for (const found of masked.matchAll(pair.pattern)) {
+      const start = found.index ?? 0;
+      const end = start + found[0].length;
+      let overlaps = false;
+      for (let i = start; i < end; i++) {
+        if (claimed[i] === 1) {
+          overlaps = true;
+          break;
+        }
+      }
+      if (overlaps || mustStayFull(pair, masked, titleLike, start, end, look)) continue;
+      claimed.fill(1, start, end);
+      const match = text.slice(start, end);
+      hits.push({ index: start, length: end - start, match, suggestion: preserveCase(match, pair.contracted) });
+    }
+  }
+  return hits.sort((a, b) => a.index - b.index);
+}
+function findUncontracted(text, options) {
+  if (typeof text !== "string" || !text) return [];
+  return scanUncontracted(text, maskProtected(text, options?.protectedRanges), options?.titleLike === true);
+}
+
+// src/contracts/sentences.ts
+var ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "mr",
+  "mrs",
+  "ms",
+  "dr",
+  "prof",
+  "st",
+  "jr",
+  "sr",
+  "vs",
+  "inc",
+  "co",
+  "corp",
+  "ltd",
+  "llc",
+  "approx",
+  "dept",
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "sept",
+  "oct",
+  "nov",
+  "dec",
+  "gen",
+  "sen",
+  "gov",
+  "lt",
+  "col",
+  "capt",
+  "sgt",
+  "cpl",
+  "maj",
+  "adm",
+  "pres",
+  "atty",
+  "bros",
+  "mfg",
+  "assoc",
+  "univ",
+  "bldg",
+  "ste",
+  "ave",
+  "blvd",
+  "rd",
+  "ln",
+  "hwy",
+  "pkwy",
+  "pl"
+]);
+var CAPITALISED_ABBREVIATIONS = /* @__PURE__ */ new Set([
+  "Mon",
+  "Tue",
+  "Tues",
+  "Wed",
+  "Thu",
+  "Thur",
+  "Thurs",
+  "Fri",
+  "Sat",
+  "Sun",
+  "Mt",
+  "Ft",
+  "Ct",
+  "Rep",
+  "Rev",
+  "Hon"
+]);
+var BEFORE_NUMBER = /* @__PURE__ */ new Set([
+  "no",
+  "nos",
+  "fig",
+  "figs",
+  "vol",
+  "vols",
+  "ch",
+  "sec",
+  "pp",
+  "cf",
+  "ca",
+  "est",
+  "ext",
+  "tel",
+  "ph",
+  "ste",
+  "apt",
+  "bldg",
+  "rm",
+  "hwy",
+  "rt",
+  "rte"
+]);
+var DOTTED_SHORT = /^\d*(?:[A-Za-z]{1,2}\.)+[A-Za-z]{1,2}$/;
+var DOTTED_CAPS = /^(?:[A-Z][A-Za-z]*\.)+[A-Z][A-Za-z]*$/;
+var ABBREVIATION_RANGE = /[A-Za-z]\.[-–—/]/;
+var LIST_MARKER_ALONE = /^\s*(?:(?:step|tip|reason|rule|point|item|option)\s+)?\d{1,3}\.$/i;
+var LIST_MARKER_AFTER_COLON = /:\s+\d{1,3}\.$/;
+var LIST_MARKER_REACH = 24;
+var OPENERS = /* @__PURE__ */ new Set(['"', "'", "\u201C", "\u2018", "(", "["]);
+var CLOSERS = /* @__PURE__ */ new Set(['"', "'", "\u201D", "\u2019", ")", "]"]);
+var SPACE = /\s/;
+var LETTER = /\p{L}/u;
+var DIGIT = /[0-9]/;
+var SENTENCE_START = /[A-Z0-9]/;
+var isStop = (c) => c === "." || c === "!" || c === "?";
+var isSpace = (c) => SPACE.test(c);
+function startsSentence(source, at) {
+  const c = OPENERS.has(source[at]) ? source[at + 1] : source[at];
+  return c !== void 0 && SENTENCE_START.test(c);
+}
+function digitFollows(source, at) {
+  const c = OPENERS.has(source[at]) ? source[at + 1] : source[at];
+  return c !== void 0 && DIGIT.test(c);
+}
+function isDottedAbbreviation(bare) {
+  const compound = Math.max(bare.lastIndexOf("-"), bare.lastIndexOf("\u2013"), bare.lastIndexOf("\u2014"), bare.lastIndexOf("/"));
+  const last = bare.slice(compound + 1);
+  return DOTTED_SHORT.test(last) || DOTTED_CAPS.test(last) || ABBREVIATION_RANGE.test(bare);
+}
+function endsWithAbbreviation(source, end, digitNext) {
+  let from = end;
+  while (from > 0 && !isSpace(source[from - 1])) from--;
+  let to = end;
+  while (from < to && OPENERS.has(source[from])) from++;
+  while (to > from && CLOSERS.has(source[to - 1])) to--;
+  while (to > from && source[to - 1] === ".") to--;
+  const bare = source.slice(from, to);
+  const lower = bare.toLowerCase();
+  return isDottedAbbreviation(bare) || /^[A-Za-z]$/.test(bare) || ABBREVIATIONS.has(lower) || CAPITALISED_ABBREVIATIONS.has(bare) || digitNext && BEFORE_NUMBER.has(lower);
+}
+function endsWithListMarker(source, start, end) {
+  const from = Math.max(start, end - LIST_MARKER_REACH);
+  const tail = source.slice(from, end);
+  return from === start && LIST_MARKER_ALONE.test(tail) || LIST_MARKER_AFTER_COLON.test(tail);
+}
+function splitSentences(text) {
+  const source = (text ?? "").trim();
+  if (!source) return [];
+  const sentences = [];
+  let start = 0;
+  let scanned = 0;
+  let sawLetter = false;
+  let i = 0;
+  while (i < source.length) {
+    if (!isStop(source[i])) {
+      i++;
+      continue;
+    }
+    let endsStrong = false;
+    while (i < source.length && isStop(source[i])) {
+      if (source[i] !== ".") endsStrong = true;
+      i++;
+    }
+    while (i < source.length && CLOSERS.has(source[i])) i++;
+    let next = i;
+    while (next < source.length && isSpace(source[next])) next++;
+    if (next === i || !startsSentence(source, next)) continue;
+    if (!sawLetter) sawLetter = LETTER.test(source.slice(scanned, i));
+    scanned = i;
+    if (!sawLetter) continue;
+    if (!endsStrong && (endsWithAbbreviation(source, i, digitFollows(source, next)) || endsWithListMarker(source, start, i))) continue;
+    sentences.push(source.slice(start, i).trim());
+    start = i;
+    sawLetter = false;
+  }
+  const rest = source.slice(start).trim();
+  if (rest) sentences.push(rest);
+  return sentences;
+}
+
+// src/contracts/business-claims.ts
+var BUSINESS_CLAIMS_CONTRACT_VERSION = 1;
+var NAMED_ENTITIES = {
+  nbsp: " ",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  sbquo: "\u201A",
+  bdquo: "\u201E",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  minus: "\u2212",
+  hellip: "\u2026",
+  middot: "\xB7",
+  bull: "\u2022",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  deg: "\xB0",
+  times: "\xD7",
+  divide: "\xF7",
+  euro: "\u20AC",
+  pound: "\xA3",
+  cent: "\xA2",
+  yen: "\xA5",
+  sect: "\xA7",
+  para: "\xB6",
+  frac12: "\xBD",
+  frac14: "\xBC",
+  frac34: "\xBE",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  thinsp: "\u2009",
+  ensp: "\u2002",
+  emsp: "\u2003",
+  zwnj: "",
+  zwj: "",
+  shy: ""
+};
+function decodeHtmlEntities(text) {
+  if (typeof text !== "string") return "";
+  if (!text.includes("&")) return text;
+  return text.replace(/&(#x[0-9a-f]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});/gi, (whole, ref) => {
+    if (ref[0] === "#") {
+      const code = ref[1] === "x" || ref[1] === "X" ? parseInt(ref.slice(2), 16) : parseInt(ref.slice(1), 10);
+      if (!Number.isFinite(code) || code <= 0 || code > 1114111 || code >= 55296 && code <= 57343) return whole;
+      return code === 160 ? " " : String.fromCodePoint(code);
+    }
+    const named = NAMED_ENTITIES[ref.toLowerCase()];
+    return named === void 0 ? whole : named;
+  });
+}
+var MIN_QUOTE_CHARS = 12;
+var INVISIBLE = /[­᠎​-‏‪-‮⁠-⁤⁦-⁩︀-️]|\uDB40[\uDC00-\uDC7F]/g;
+function foldMatchable(text) {
+  return text.normalize("NFKC").replace(INVISIBLE, "").replace(/[‘’‚‛′`´]/g, "'").replace(/[“”„‟″]/g, '"').replace(/[‐-―−]/g, "-").replace(/\s+/g, " ").replace(/\s*-\s*/g, "-").replace(/\$\s+(?=\d)/g, "$").trim().toLowerCase();
+}
+function normalizeForQuote(text) {
+  const raw = typeof text === "string" ? text : typeof text === "number" ? String(text) : "";
+  return foldMatchable(decodeHtmlEntities(raw));
+}
+function normalizeMatchable(text) {
+  return normalizeForQuote(text);
+}
+function isWholeSpan(haystack, needle, at) {
+  const first = needle[0];
+  const last = needle[needle.length - 1];
+  const before = haystack.slice(Math.max(0, at - 2), at);
+  const after = haystack.slice(at + needle.length, at + needle.length + 2);
+  const glueBefore = /\d/.test(first) && /(\d|\d[.,])$/.test(before) || /\p{L}/u.test(first) && /\p{L}$/u.test(before);
+  const glueAfter = /\d/.test(last) && /^(\d|[.,]\d|k(?!\p{L}))/u.test(after) || /\p{L}/u.test(last) && /^\p{L}/u.test(after);
+  return !glueBefore && !glueAfter;
+}
+function wholeSpanAt(haystack, needle) {
+  if (!needle) return -1;
+  for (let at = haystack.indexOf(needle); at >= 0; at = haystack.indexOf(needle, at + 1)) {
+    if (isWholeSpan(haystack, needle, at)) return at;
+  }
+  return -1;
+}
+function wholeSpansOf(haystack, needle) {
+  const out = [];
+  if (!needle) return out;
+  for (let at = haystack.indexOf(needle); at >= 0; at = haystack.indexOf(needle, at + 1)) {
+    if (isWholeSpan(haystack, needle, at)) out.push(at);
+  }
+  return out;
+}
+function quoteFoundIn(quote, normalizedSource, minChars = MIN_QUOTE_CHARS) {
+  const needle = normalizeForQuote(quote);
+  return needle.length >= minChars && wholeSpanAt(normalizedSource, needle) >= 0;
+}
+var MONEY_TOKEN = /\$\d[\d,]*(?:\.\d+)?(?:k(?![a-z]))?/g;
+function moneyAmounts(normalized) {
+  return (normalized.match(MONEY_TOKEN) ?? []).map((token) => {
+    const thousands = token.endsWith("k");
+    const n = Number(token.replace(/[$,k]/g, "").replace(/\.$/, ""));
+    return thousands ? n * 1e3 : n;
+  }).filter((n) => Number.isFinite(n));
+}
+var PRICE_RANGE_BEFORE = /(?:\b(?:from|starting at|starts at|as low as|up to|under|over|at least)|\dk?\s*(?:-|to))\s*$/;
+var PRICE_RANGE_AFTER = /^\s*(?:\+|-\s*\$?\d|to\s+\$?\d)/;
+function checkQuotedPrice(display, quote) {
+  const shown = normalizeForQuote(display);
+  const text = normalizeForQuote(quote);
+  if (!shown) return null;
+  const at = wholeSpanAt(text, shown);
+  if (at < 0) return null;
+  if (PRICE_RANGE_BEFORE.test(text.slice(Math.max(0, at - 16), at)) || PRICE_RANGE_AFTER.test(text.slice(at + shown.length, at + shown.length + 16))) {
+    return null;
+  }
+  const amounts = moneyAmounts(shown);
+  if (!amounts.length) return /\bfree\b/.test(shown) ? {} : null;
+  const min = Math.min(...amounts);
+  const max = Math.max(...amounts);
+  if (amounts.length === 1 && (/\$[\d,.]+k?\+/.test(shown) || /^(?:from|starting at|starts at)\b/.test(shown))) return { min };
+  return { min, max };
+}
+function numbersIn(normalized) {
+  return (normalized.match(/\d[\d,.]*/g) ?? []).map((n) => n.replace(/[.,]+$/, "").replace(/,/g, "")).filter(Boolean);
+}
+function numbersGrounded(value, quote) {
+  const have = new Set(numbersIn(normalizeForQuote(quote)));
+  return numbersIn(normalizeForQuote(value)).every((n) => have.has(n));
+}
+function removeDashes(text) {
+  return text.replace(/(\d)\s*[–—]\s*(?=\$)/g, "$1 - ").replace(/(\d)\s*[–—]\s*(?=\d)/g, "$1-").replace(/\s+–\s+(?=\d)/g, " - ").replace(/(\w)–(?=\w)/g, "$1-").replace(/\s*[–—]\s*/g, ", ").replace(/,\s*,/g, ",");
+}
+var WRITER_NOTE_PATTERNS = [
+  /\bunverified\b/i,
+  /\bwithout (?:attributing|assuming|speculating)\b/i,
+  /\bowner notes\b/i,
+  /\b(?:real data|measured) block\b/i,
+  /\bthe (?:data|evidence|information) (?:provided|given|supplied)\b/i,
+  /\b(?:can(?:no|['’])t|could(?:n['’]t| not)) (?:be )?(?:verif(?:y|ied)|confirm(?:ed)?)\b/i,
+  /\bnot recorded\b/i
+];
+function isWriterNote(text) {
+  if (typeof text !== "string" || !text) return false;
+  return WRITER_NOTE_PATTERNS.some((pattern) => pattern.test(text));
+}
+var ATTRS = `(?:[^>"']|"[^"]*"|'[^']*')*`;
+var IMG_TAG = new RegExp(`<img\\b${ATTRS}>`, "gi");
+var LINK = new RegExp(`<a\\b(${ATTRS})>([\\s\\S]*?)<\\/a\\s*>`, "gi");
+var TITLED_TAG = new RegExp(`<[a-z][a-z0-9-]*\\s${ATTRS}\\btitle\\s*=${ATTRS}>`, "gi");
+var BLOCK_TAG = new RegExp(`<\\/?(?:p|div|li|ul|ol|h[1-6]|tr|table|tbody|thead|tfoot|blockquote|section|article|header|footer|hr|pre|center)\\b${ATTRS}>`, "gi");
+var CELL_TAG = new RegExp(`<\\/?(?:td|th)\\b${ATTRS}>`, "gi");
+var ANY_TAG = new RegExp(`<\\/?[a-z][a-z0-9:-]*(?:\\s${ATTRS})?\\/?>`, "gi");
+function attributeOf(tag, name) {
+  const found = new RegExp(`[\\s"']${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i").exec(tag);
+  return found ? found[1] ?? found[2] ?? found[3] ?? "" : null;
+}
+function linkTextIsAddress(text, href) {
+  const shown = text.trim().toLowerCase().replace(/\/$/, "");
+  const target = href.trim().toLowerCase().replace(/\/$/, "");
+  return !!shown && (shown === target || `mailto:${shown}` === target || `tel:${shown}` === target);
+}
+function outboundPlainText(body, format) {
+  const raw = typeof body === "string" ? body : "";
+  if (format !== "html") return decodeHtmlEntities(raw);
+  const html = raw.replace(/<!--[\s\S]*?(?:-->|$)/g, " ").replace(/<(script|style)\b[\s\S]*?(?:<\/\1\s*>|$)/gi, " ").replace(/\s+/g, " ").replace(IMG_TAG, (tag) => {
+    const words = [attributeOf(tag, "alt"), attributeOf(tag, "title")].filter((v) => !!v && !!v.trim());
+    return words.length ? `
+${words.join("\n")}
+` : "";
+  }).replace(LINK, (_whole, attrs, inner) => {
+    const tag = ` ${attrs}`;
+    const href = attributeOf(tag, "href");
+    const title = attributeOf(tag, "title");
+    const shown = decodeHtmlEntities(inner.replace(ANY_TAG, "")).replace(/\s+/g, " ");
+    const target = href === null ? "" : decodeHtmlEntities(href).trim();
+    const showTarget = !!target && !/^(?:#|javascript:)/i.test(target) && !linkTextIsAddress(shown, target);
+    return `${inner}${showTarget ? ` (${href.trim()})` : ""}${title && title.trim() ? `
+${title}
+` : ""}`;
+  }).replace(TITLED_TAG, (tag) => {
+    const title = attributeOf(tag, "title");
+    return title && title.trim() ? `${tag}
+${title}
+` : tag;
+  }).replace(/<br\s*\/?>/gi, "\n").replace(BLOCK_TAG, "\n").replace(CELL_TAG, " ").replace(ANY_TAG, "");
+  return decodeHtmlEntities(html).split(/\r\n?|\n/).map((line) => line.replace(/\s+/g, " ").trim()).filter(Boolean).join("\n");
+}
+var OUTBOUND_AUTHORS = ["signal", "agent", "operator"];
+function fnv1a(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function outboundFindingId(code, sentence, match) {
+  return fnv1a(`${code}\0${foldMatchable(sentence)}\0${foldMatchable(match)}`);
+}
+var DEFAULT_COPY = {
+  empty_subject: { reason: "The subject line is empty.", fix: "Add a short subject." },
+  empty_body: { reason: "The message has almost nothing in it.", fix: "Write the message before it goes out." },
+  unrendered_token: { reason: "It has a placeholder that was never filled in.", fix: "Put in the real value or take it out." },
+  platform_banned_claim: { reason: "It makes a promise Sonor never lets an email make.", fix: "Take the promise out and say what you'll actually do." },
+  project_banned_claim: { reason: "It says something the Business Brief says never to claim.", fix: "Take it out or say it another way." },
+  forbidden_phrase: { reason: "It uses a phrase this outreach angle never says.", fix: "Take it out or say it another way." },
+  price_mismatch: { reason: "It names a price that doesn't match a published one.", fix: "Use the price as published, or leave the price out." },
+  mixed_script: { reason: "A word mixes letters from two alphabets, so it only looks like a normal word.", fix: "Retype it with ordinary letters." },
+  dash: { reason: "It uses an em or en dash.", fix: "Use a comma, a period or a plain hyphen." },
+  unsafe_markup: { reason: "The HTML has markup email clients strip or flag as spam.", fix: "Send plain HTML without scripts, styles or event handlers." },
+  prompt_control_token: { reason: "It has text meant for an AI, not the reader.", fix: "Take it out." },
+  price_unverifiable: { reason: "It names a price that isn't published, so it can't be checked.", fix: "Publish your prices in the Business Brief, or check this one by hand." },
+  unsupported_number: { reason: "Nothing on record backs up a number in it.", fix: "Cite a verified fact from the Business Brief, or take the number out." },
+  citation_invalid: { reason: "It cites a fact that isn't in the Business Brief.", fix: "Cite a verified fact, or take the claim out." },
+  citation_mismatch: { reason: "A number in it isn't in the source it cites.", fix: "Match what the source says, or take it out." },
+  citation_wrong_source: { reason: "It makes a claim about the sender that only research about the recipient backs.", fix: "Cite a fact from the Business Brief, or take it out." },
+  banned_claim_negated: { reason: "It brings up a promise Sonor never lets an email make, while saying it can't make it.", fix: "Keep it only if it clearly reads as a disclaimer." },
+  writer_note: { reason: "It reads like a note about how the copy was written, not something for the reader.", fix: "Take it out or say what's true instead." },
+  number_from_research: { reason: "A number in it comes from the research about the recipient.", fix: "Make sure it's still true before it goes out." },
+  audit_flag: { reason: "Signal's fact check flagged this.", fix: "Check it's true before you approve it." },
+  audit_not_run: { reason: "Signal couldn't check this email's claims.", fix: "Read it over before you approve it." },
+  uncontracted: { reason: "It reads stiff.", fix: "Use the contraction." },
+  first_person_firm: { reason: "It says I for work the business does.", fix: "Say we for the business, and keep I for what you noticed yourself." }
+};
+function makeOutboundFinding(code, sentence, match, extra = {}) {
+  const copy = DEFAULT_COPY[code] ?? { reason: "Check this before it goes out.", fix: "Fix it or take it out." };
+  const finding = {
+    id: outboundFindingId(code, sentence, match),
+    code,
+    sentence,
+    match,
+    reason: extra.reason ?? copy.reason,
+    fix: extra.fix ?? copy.fix
+  };
+  if (extra.fact_id) finding.fact_id = extra.fact_id;
+  return finding;
+}
+var PLATFORM_BANNED_CLAIMS = [
+  { id: "guaranteed_ranking", description: "Guarantees or promises a search ranking (page one, first page, a top spot)." },
+  { id: "number_one_on_google", description: "Promises a #1 or top spot on Google." },
+  { id: "guaranteed_results", description: "Guarantees results, leads, traffic, sales or a growth figure." },
+  { id: "hundred_percent_guaranteed", description: "Promises a 100% guarantee." },
+  { id: "risk_free", description: "Calls an offer risk free or zero risk." },
+  { id: "fake_scarcity", description: "Manufactured urgency: spots left, limited-time offers, act now, last chance." },
+  { id: "google_endorsed", description: "Says Google endorses, approves or recommends the sender, or that the sender writes for Google." },
+  {
+    id: "pay_nothing_guarantee",
+    description: `Promises the prospect pays nothing, pays only for results or gets their money back: "or you pay nothing", "no results, no fee", "if we don't, you don't pay", a money-back or refund guarantee.`
+  }
+];
+var PLATFORM_CLAIM_REASON = {
+  guaranteed_ranking: "It promises a search ranking, and nobody controls where Google ranks a site.",
+  number_one_on_google: "It promises a #1 spot on Google, which nobody can promise.",
+  guaranteed_results: "It guarantees results that depend on things nobody controls.",
+  hundred_percent_guaranteed: "It promises a 100% guarantee.",
+  risk_free: "It calls the offer risk free.",
+  fake_scarcity: "It pushes urgency or scarcity that isn't real.",
+  google_endorsed: "It says Google endorses or works with the sender.",
+  pay_nothing_guarantee: "It promises they pay nothing or get their money back, and outreach never offers that."
+};
+var PLATFORM_CLAIM_NAME = {
+  guaranteed_ranking: "a guaranteed ranking",
+  number_one_on_google: "a #1 spot on Google",
+  guaranteed_results: "guaranteed results",
+  hundred_percent_guaranteed: "a 100% guarantee",
+  risk_free: "a risk free offer",
+  fake_scarcity: "urgency",
+  google_endorsed: "Google's backing",
+  pay_nothing_guarantee: "a pay-nothing guarantee"
+};
+var GUARANTEE = String.raw`(?:guarantee[sd]?|guaranteeing|guaranty|promise[sd]?|promising)`;
+var CLAUSE_GAP = String.raw`(?:(?!\b(?:or|but|and|so|because|if|unless|until|while)\b)[^.!?;:,]){0,60}?`;
+var RANK_WORD = String.raw`(?<![a-z0-9])(?:rank(?:s|ed|ing|ings)?(?![a-z])|page[- ]?(?:one|1)(?![a-z0-9])|(?:first|front)-?page|(?:first|front) page(?=\s*(?:$|[.!?;:,)])|\s+(?:on|of|in)\s+(?:google|bing|search)|\s+(?:rankings?|results?|placements?|positions?|spots?)(?![a-z]))|top (?:spot|position|result|ranking)s?|#\s?1(?![0-9])|number-?one|no\.\s?1(?![0-9])|first place|top[- ]?(?:\d{1,2}|three|five|ten)(?![0-9a-z%])(?!\s?(?:percent|seconds?|secs?|minutes?|mins?|hours?|days?|weeks?|months?|years?)(?![a-z]))|(?:map|local|3)-? ?pack(?![a-z]))`;
+var RESULT_WORD = String.raw`(?<![a-z0-9])(?:results?|leads?|traffic|sales|revenue|roi|growth|customers|clients|calls|bookings|conversions|more business|(?:an? )?(?:increase|boost|spike)|\d+(?:\.\d+)?\s?(?:%|x(?![a-z])|percent))(?![a-z])`;
+var TOP_OF_GOOGLE = String.raw`(?<![a-z0-9])(?:#\s?1|number-?one|no\.\s?1|first (?:place|position|spot|result)|(?:the )?top (?:spot|position|result)|(?:the )?top)\s+(?:spot\s+|position\s+|result\s+|ranking\s+)?(?:on|of|in)\s+google(?![a-z])`;
+var AFTER_GUARANTEE = String.raw`(?:\s*:)?${CLAUSE_GAP}`;
+var GUARANTEED_AFTER_OUTCOME = String.raw`(?:${RESULT_WORD}|\b(?:will|going to)\b|'ll\b)[^.!?;:]{0,80}?,\s*guaranteed(?=\s*(?:[.!?]|$))`;
+var TO_THE_TOP = String.raw`\b(?:get|gets|got|getting|put|puts|putting|take|takes|took|taking|land|lands|landed|landing|bring|brings|brought|push|pushes|pushed|move|moves|moved|help|helps|helped|rank|ranks|ranked|ranking|be|keep|keeps|kept)\b${CLAUSE_GAP}`;
+var PAY_NOTHING = [
+  String.raw`\bor (?:else )?(?:you|they|you'll|you will) (?:pay nothing|pay \$?0(?![0-9])|owe (?:us )?nothing|don't pay|do not pay|won't pay|will not pay|don't owe|get (?:it (?:for )?free|(?:a |your |all your |every penny |a full )?(?:money|refund)(?: back)?))`,
+  String.raw`\bor (?:it's|its|it is|that's|the (?:work|site|month|project|first month) is) (?:free|on us|on the house)\b`,
+  String.raw`\bor (?:we|we'll|we will) (?:refund|give (?:you )?(?:your |all your |every penny of your )?money back|work for free|waive)`,
+  String.raw`\bor (?:your|their) money back\b`,
+  String.raw`\b(?:pay nothing|don't pay(?: a (?:dime|cent|penny|thing))?|do not pay|owe (?:us )?nothing|pay \$?0(?![0-9]))\b[^.!?;:]{0,20}?\b(?:unless|until|if)\b`,
+  String.raw`\bno (?:results?|leads?|rankings?|growth|sales|calls|traffic|improvement),? no (?:pay|fees?|charge|cost|bill|invoice|payment)\b`,
+  String.raw`\b(?:only )?pay (?:only )?(?:for|when|if|once|after) (?:you |we )?(?:see |get |deliver |hit |start (?:to )?see(?:ing)? )?(?:real )?(?:results?|leads?|rankings?|growth|sales|more (?:calls|leads|customers|business))\b`,
+  String.raw`\bif (?:we|it|the site|this) (?:don't|doesn't|do not|does not|can't|cannot|fail to|won't|didn't)\b[^.!?;:]{0,80}?\b(?:you don't pay|you do not pay|you won't pay|you pay nothing|you owe nothing|don't pay|pay nothing|owe nothing|(?:you )?get (?:your |a full |a )?(?:money back|refund)|(?:it's|its|it is) free|we(?:'ll| will)? refund)`,
+  String.raw`\b(?:money-?back|money back|full-?refund|refund|pay-?nothing|no-?pay) guarantee[sd]?\b|\bguaranteed? (?:a )?(?:full )?refund\b|\bfull refund if\b|\bfree (?:if|unless) (?:we|it)\b`
+];
+var PLATFORM_PATTERNS = [
+  {
+    id: "guaranteed_ranking",
+    pattern: new RegExp(
+      String.raw`\b${GUARANTEE}\b${AFTER_GUARANTEE}${RANK_WORD}|${RANK_WORD}[^.!?;:]{0,30}?\b(?:are |is |will be )?(?:not |never |n't )?guaranteed\b`,
+      "g"
+    )
+  },
+  { id: "number_one_on_google", pattern: new RegExp(`${TO_THE_TOP}${TOP_OF_GOOGLE}`, "g"), verb: true },
+  {
+    id: "guaranteed_results",
+    pattern: new RegExp(
+      String.raw`\b${GUARANTEE}\b${AFTER_GUARANTEE}${RESULT_WORD}|(?<![a-z])(?:results?|leads|traffic|sales|revenue|roi|growth|conversions),?\s+(?:are\s+|is\s+|will be\s+)?guaranteed\b|${GUARANTEED_AFTER_OUTCOME}`,
+      "g"
+    )
+  },
+  {
+    id: "hundred_percent_guaranteed",
+    pattern: /(?:100\s?%|100 percent|(?:one )?hundred percent)\s+(?:satisfaction\s+)?(?:guaranteed|guarantee[sd]?|money-back|risk-?free|results)\b|\bguaranteed\s+100\s?%/g
+  },
+  { id: "risk_free", pattern: /\brisk-?free\b|\brisk free\b|\bzero-?risk\b|\bno risk (?:to you|whatsoever|at all|involved)\b|\bwithout any risk\b/g },
+  {
+    id: "fake_scarcity",
+    pattern: /\bonly \d+ (?:spots?|slots?|openings?|places?|seats?|positions?)\b[^.!?]{0,20}?\b(?:left|remaining|available)\b|\b(?:\d+|few|limited) (?:spots?|slots?|openings?) (?:left|remaining)\b|\blimited-?time (?:offer|only|deal|discount|pricing|price)\b|\blimited time (?:offer|only|deal|discount|pricing|price)\b|\bact (?:now|fast|quickly)\b|\b(?:offer|deal|discount|pricing|price|sale) (?:ends|expires) (?:today|tonight|tomorrow|soon|at midnight|this week|friday)\b|\blast chance\b|\b(?:offer|deal|price|pricing|discount)s? (?:won't|will not|wont) last\b|\bspots? (?:are )?filling (?:up )?fast\b|\bwhile (?:spots|supplies) last\b/g
+  },
+  {
+    id: "google_endorsed",
+    verb: true,
+    pattern: /\b(?:endorsed|approved|recommended|backed|sponsored|authorized) by google\b|\bgoogle-(?:endorsed|approved|recommended|backed|sponsored|authorized)\b|\bon behalf of google\b|\b(?:calling|writing|reaching out|emailing) from google\b|\bgoogle (?:recommends|endorses|approves of) (?:us|our)\b/g
+  },
+  { id: "pay_nothing_guarantee", pattern: new RegExp(PAY_NOTHING.join("|"), "g") }
+];
+var GUARANTEE_WORD = new RegExp(String.raw`\b${GUARANTEE}\b`, "g");
+var GOVERNING_NEGATION = /(?:^|[^a-z'])(?:can't|cannot|cant|can not|don't|dont|do not|won't|wont|will not|never|not|isn't|aren't|doesn't|does not|didn't|couldn't|wouldn't|shouldn't|wasn't|weren't|no one can|nobody can|no one could|nobody could)\s+$/;
+var NEVER_SUPPRESS = /(?:^|[^a-z'])(?:not only|no other|don't settle|don't wait|don't miss)\b[^.!?;:,]*$/;
+function governingVerbsAt(text, start, end, leadingVerb) {
+  const inside = new RegExp(GUARANTEE_WORD.source, "g").exec(text.slice(start, end));
+  if (inside) return [start + inside.index];
+  const verbs = leadingVerb ? [start] : [];
+  let clauseStart = 0;
+  for (let i = start - 1; i >= 0; i--) {
+    if (".!?;:,\n".includes(text[i])) {
+      clauseStart = i + 1;
+      break;
+    }
+  }
+  let last = -1;
+  for (const found of text.slice(clauseStart, start).matchAll(new RegExp(GUARANTEE_WORD.source, "g"))) last = clauseStart + (found.index ?? 0);
+  if (last >= 0) verbs.push(last);
+  return verbs;
+}
+function negatedHit(text, start, end, leadingVerb) {
+  return governingVerbsAt(text, start, end, leadingVerb).some((verb) => {
+    const before = text.slice(Math.max(0, verb - 40), verb);
+    return !NEVER_SUPPRESS.test(before) && GOVERNING_NEGATION.test(before);
+  });
+}
+function platformHits(norm) {
+  const hits = [];
+  for (const { id, pattern, verb } of PLATFORM_PATTERNS) {
+    for (const found of norm.matchAll(pattern)) {
+      const index = found.index ?? 0;
+      hits.push({ id, index, match: found[0], negated: negatedHit(norm, index, index + found[0].length, verb === true) });
+    }
+  }
+  return hits.sort((a, b) => a.index - b.index);
+}
+function findPlatformBannedClaims(text) {
+  return platformHits(normalizeForQuote(text));
+}
+function phraseHits(norm, phrases) {
+  const hits = [];
+  for (const phrase of phrases ?? []) {
+    if (typeof phrase !== "string") continue;
+    const needle = normalizeForQuote(phrase);
+    if (needle.length < 2) continue;
+    for (const index of wholeSpansOf(norm, needle)) hits.push({ phrase, index, match: needle });
+  }
+  return hits.sort((a, b) => a.index - b.index);
+}
+function findPhrases(text, phrases) {
+  return phraseHits(normalizeForQuote(text), phrases);
+}
+var TOKEN_PATTERNS = [
+  /\{\{[^{}]{0,80}\}\}/g,
+  /\{%[^%]{0,80}%\}/g,
+  /\[\[[^[\]]{0,80}\]\]/g,
+  /%[a-z][a-z0-9_]{1,40}%/g,
+  /\$\{[^{}]{0,80}\}/g,
+  /\{[^{}|]{1,80}(?:\|[^{}|]{0,80})+\}/g,
+  /\{[a-z_][a-z0-9_. ]{0,40}\}/g,
+  /\[(?:(?:your|their|his|her|the|recipient's|prospect's|client's|contact's|sender's)\s)?(?:(?:first|last|full|company|business|contact|recipient|prospect|client|sender|agency|website|site|city|state|job)\s)?(?:name|first-?name|last-?name|company|business|city|state|website|url|link|title|role|industry|position|niche|location|address|phone|email|date|personali[sz]ation|personali[sz]ed (?:line|opener|intro)|opening line|compliment|pain point|insert [a-z' ]{1,30})\]/g,
+  /\[object object\]/g,
+  /\b(?:hi|hello|hey|dear|good (?:morning|afternoon|evening)|thanks|thank you)[ ,]+(?:undefined|null|nan)\b/g
+];
+function tokenHits(norm) {
+  const hits = [];
+  for (const pattern of TOKEN_PATTERNS) {
+    for (const found of norm.matchAll(pattern)) hits.push({ index: found.index ?? 0, match: found[0] });
+  }
+  hits.sort((a, b) => a.index - b.index || b.match.length - a.match.length);
+  const kept = [];
+  let reach = -1;
+  for (const hit of hits) {
+    if (hit.index + hit.match.length <= reach) continue;
+    kept.push(hit);
+    reach = Math.max(reach, hit.index + hit.match.length);
+  }
+  return kept;
+}
+function findUnrenderedTokens(text) {
+  return tokenHits(normalizeForQuote(text));
+}
+var EM_DASHES = /[—―⸺⸻]/;
+function findDashes(text) {
+  const source = typeof text === "string" ? text : "";
+  const hits = [];
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (EM_DASHES.test(c)) {
+      hits.push({ index: i, match: c, kind: "em" });
+      continue;
+    }
+    if (c !== "\u2013" && c !== "\u2012") continue;
+    let p = i - 1;
+    while (p >= 0 && /\s/.test(source[p])) p--;
+    let n = i + 1;
+    while (n < source.length && /\s/.test(source[n])) n++;
+    const before = p >= 0 ? source[p] : "";
+    const after = n < source.length ? source[n] : "";
+    if (!before || !after) continue;
+    if (/\d/.test(before) || /[\d$]/.test(after)) continue;
+    const spaced = p !== i - 1 || n !== i + 1;
+    if (!spaced && /\p{L}/u.test(before) && /\p{L}/u.test(after)) continue;
+    hits.push({ index: i, match: c, kind: "en" });
+  }
+  return hits;
+}
+function findMixedScript(text) {
+  const source = typeof text === "string" ? text.normalize("NFKC").replace(INVISIBLE, "") : "";
+  const hits = [];
+  for (const found of source.matchAll(/[\p{L}\p{M}]+/gu)) {
+    const word = found[0];
+    if (word.length < 2) continue;
+    if (/\p{Script=Latin}/u.test(word) && /[\p{Script=Cyrillic}\p{Script=Greek}]/u.test(word)) {
+      hits.push({ index: found.index ?? 0, match: word });
+    }
+  }
+  return hits;
+}
+var UNSAFE_MARKUP = [
+  { pattern: /<style\b/i, what: "a style block" },
+  { pattern: /<script\b/i, what: "a script" },
+  { pattern: /<[a-z][a-z0-9-]*\b[^>]*\son[a-z]+\s*=/i, what: "an event handler (on...=)" },
+  { pattern: /\bstyle\s*=\s*(?:"[^"]*\bcontent\s*:|'[^']*\bcontent\s*:)/i, what: "CSS content:" },
+  { pattern: /<(?:iframe|object|embed)\b/i, what: "an embedded frame or object" },
+  { pattern: /\bhref\s*=\s*["']?\s*javascript:/i, what: "a javascript: link" }
+];
+function findUnsafeMarkup(html) {
+  const source = typeof html === "string" ? html : "";
+  const hits = [];
+  for (const { pattern, what } of UNSAFE_MARKUP) {
+    const found = pattern.exec(source);
+    if (found) hits.push({ index: found.index, match: what });
+  }
+  return hits;
+}
+var AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?:\s?(?:k|m|million|thousand)(?![a-z]))?`;
+var FLOOR_WORDS = /* @__PURE__ */ new Set(["starting at", "starts at", "start at", "starting from", "from", "as low as", "as little as", "at least", "over", "more than"]);
+var PRICE_MENTION = new RegExp(
+  String.raw`\b(between)\s+\$(${AMOUNT})\s+and\s+\$?(${AMOUNT})|(?:\b(starting at|starts at|start at|starting from|from|as low as|as little as|up to|under|over|at least|at most|less than|more than|no more than)\s+)?\$(${AMOUNT})(\+)?(?:(?:-|\s+to\s+)\$?(${AMOUNT}))?`,
+  "g"
+);
+function amountValue(written) {
+  const m = /^([\d,]+(?:\.\d+)?)\s?(k|m|million|thousand)?$/.exec(written.trim());
+  if (!m) return NaN;
+  const n = Number(m[1].replace(/,/g, ""));
+  const unit = m[2];
+  return unit === "k" || unit === "thousand" ? n * 1e3 : unit === "m" || unit === "million" ? n * 1e6 : n;
+}
+function priceMentionsIn(norm) {
+  const out = [];
+  for (const found of norm.matchAll(PRICE_MENTION)) {
+    const index = found.index ?? 0;
+    if (found[1]) {
+      const a = amountValue(found[2]);
+      const b = amountValue(found[3]);
+      if (!Number.isFinite(a) || !Number.isFinite(b)) continue;
+      out.push({ index, match: found[0], shape: "range", min: Math.min(a, b), max: Math.max(a, b), amounts: [found[2], found[3]] });
+      continue;
+    }
+    const words = found[4];
+    const first = amountValue(found[5]);
+    const second = found[7] ? amountValue(found[7]) : NaN;
+    if (!Number.isFinite(first)) continue;
+    if (found[7] && Number.isFinite(second)) {
+      out.push({ index, match: found[0], shape: "range", min: Math.min(first, second), max: Math.max(first, second), amounts: [found[5], found[7]] });
+      continue;
+    }
+    const shape = found[6] || words && FLOOR_WORDS.has(words) ? "floor" : words ? "ceiling" : "exact";
+    out.push({ index, match: found[0], shape, min: first, max: first, amounts: [found[5]] });
+  }
+  return out;
+}
+function findPriceMentions(text) {
+  return priceMentionsIn(normalizeForQuote(text));
+}
+var sameAmount = (a, b) => Math.abs(a - b) < 5e-3;
+function samePrice(a, b) {
+  return a.shape === b.shape && sameAmount(a.min, b.min) && sameAmount(a.max, b.max);
+}
+var NUMBER_MASK = "\u2800";
+var mask = (m) => NUMBER_MASK.repeat(m.length);
+var NOT_CLAIM_NUMBERS = [
+  /(?:https?:\/\/|www\.)\S+/g,
+  /[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g,
+  /\b[a-z0-9-]+(?:\.[a-z0-9-]+)*\.(?:com|net|org|io|co|us|dev|app|ai|biz|info|me|site|online|tech|agency|pro|xyz|ca|uk|de|au)\b(?:\/\S*)?/g,
+  /(?:\+?1[-. ]?)?\(?\d{3}\)?[-. ]?\d{3}[-.]\d{4}\b/g,
+  /\b\d{1,2}(?::\d{2})?\s?(?:a\.?m\.?|p\.?m\.?)(?![a-z])/g,
+  /\b\d{1,2}:\d{2}(?::\d{2})?\b/g,
+  /\b\d{1,4}\/\d{1,2}(?:\/\d{2,4})?\b/g,
+  /\b\d{4}-\d{1,2}-\d{1,2}\b/g,
+  /\b(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\.?\s\d{1,2}(?:st|nd|rd|th)?(?:,?\s\d{4})?\b/g,
+  /\b\d{1,2}(?:st|nd|rd|th)?\s(?:of\s)?(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\.?(?:,?\s\d{4})?\b/g,
+  /\b(?:in|within the next|next|every|each|after|per|for the next|over the next)\s(?:a\s)?(?:few\s|couple(?: of)?\s)?\d+\s(?:hours?|days?|weeks?|months?|years?)\b/g,
+  /\b\d+-?\s?min(?:ute)?s?\s(?:call|chat|meeting|conversation|demo|walkthrough|consult(?:ation)?|intro|zoom|phone call|review|look)\b/g,
+  /\b\d+\smin(?:ute)?s?\s(?:of your time|to (?:chat|talk|connect))\b/g,
+  /\b\d+\s(?:[a-z0-9.'-]+\s){0,3}(?:st|street|ave|avenue|rd|road|blvd|boulevard|dr|drive|ln|lane|way|ct|court|pl|place|pkwy|parkway|hwy|highway|cir|circle|ter|terrace)\b/g,
+  /(?:\b(?:suite|ste\.?|unit|apt\.?)\s?|#\s?)\d+\b/g,
+  /\b[a-z]{2}\s\d{5}(?:-\d{4})?\b/g,
+  /(?<!\b(?:since|founded in|established in|started in|opened in|est\.?)\s)\b(?:19|20)\d{2}\b/g,
+  /\b\d+(?:st|nd|rd|th)\b/g,
+  /\b(?:301|302|400|401|403|404|410|500|502|503)(?=[\s-]?(?:page|error|status|code|redirect|not found)s?\b)/g,
+  /(?<=[a-z])\d+(?:\.\d+)?/g,
+  /\b\d+(?:\.\d+)?(?=[a-z])(?!(?:k|x|m)(?![a-z]))[a-z]+/g
+];
+var CLAIM_NOUN_AFTER = /^(?:\s?-\s?|\s)(?:[a-z'-]+\s)?(?:clients?|customers?|projects?|sites?|websites?|pages?|years?|months?|weeks?|days?|hours?|minutes?|mins?|seconds?|secs?|ms|milliseconds?|reviews?|stars?|ratings?|awards?|businesses|business|companies|company|brands?|leads?|calls?|jobs?|homes?|houses?|locations?|offices?|employees?|people|staff|members?|partners?|cities|states?|countries|campaigns?|apps?|stores?|restaurants?|patients?|students?|users?|visitors?|visits?|sales|deals?|installs?|orders?|bookings?|appointments?|referrals?|points?|positions?|spots?|keywords?|backlinks?|links?|errors?|issues?)\b/;
+function claimNumbersIn(norm, excludeMoney) {
+  let masked = norm;
+  if (excludeMoney) {
+    for (const price of priceMentionsIn(norm)) masked = masked.slice(0, price.index) + mask(price.match) + masked.slice(price.index + price.match.length);
+  }
+  for (const pattern of NOT_CLAIM_NUMBERS) masked = masked.replace(pattern, mask);
+  const out = [];
+  for (const found of masked.matchAll(/\$?\d[\d,]*(?:\.\d+)?/g)) {
+    const index = found.index ?? 0;
+    const token = found[0].replace(/[,.]+$/, "");
+    if (/[\d.,]/.test(masked[index - 1] ?? "")) continue;
+    const money = token.startsWith("$");
+    if (money && excludeMoney) continue;
+    const value = token.replace(/[$,]/g, "");
+    if (!/\d/.test(value)) continue;
+    const end = index + token.length;
+    const after = masked.slice(end, end + 48);
+    const percent = /^\s?(?:%|percent(?![a-z]))/.exec(after);
+    const multiplier = /^(?:x(?![a-z])|×|\s?times\s(?:more|faster|better|higher|bigger|larger|as|the)\b)/.exec(after);
+    const thousands = /^k(?![a-z])/.exec(after);
+    const suffix = percent?.[0] ?? multiplier?.[0] ?? thousands?.[0] ?? "";
+    const kind = percent ? "percent" : multiplier ? "multiplier" : money ? "money" : "count";
+    const amount = Number(value) * (thousands ? 1e3 : 1);
+    if (kind === "count" && !(amount >= 11) && !CLAIM_NOUN_AFTER.test(after)) continue;
+    out.push({ index, match: norm.slice(index, end + suffix.length).trim(), value, kind });
+  }
+  return out;
+}
+function findUnsupportedNumbers(text, sources = []) {
+  const have = new Set(sources.flatMap((source) => numbersIn(normalizeForQuote(source))));
+  return claimNumbersIn(normalizeForQuote(text), false).filter((n) => !have.has(n.value));
+}
+var SUBJECT_PRONOUN = /(?<![\p{L}\p{N}'])(we|our|ours|us|ourselves|i|me|my|mine|myself|you|your|yours|yourself|yourselves)(?:['’](?:re|ve|ll|d|m|s))?(?![\p{L}\p{N}])/gu;
+var SENDER_PRONOUNS = /* @__PURE__ */ new Set(["we", "our", "ours", "us", "ourselves", "i", "me", "my", "mine", "myself"]);
+var OBSERVER_PRONOUNS = /* @__PURE__ */ new Set(["i", "we"]);
+var OBSERVATION_VERB = /^\s+(?:(?:just|also|recently)\s+)?(?:noticed|saw|see|read|looked|checked|ran|found|measured|reviewed)\b/;
+function claimSubjectOf(sentence, index, names = {}) {
+  const text = (typeof sentence === "string" ? sentence : "").slice(0, Math.max(0, index)).toLowerCase();
+  let clauseStart = 0;
+  for (let i = text.length - 1; i >= 0; i--) {
+    if (",;:\n\u2013\u2014".includes(text[i]) || text[i] === "-" && text[i - 1] === " ") {
+      clauseStart = i + 1;
+      break;
+    }
+  }
+  const afterStop = clauseStart;
+  for (const found of text.slice(afterStop).matchAll(/\b(?:and|but)\b/g)) {
+    clauseStart = afterStop + (found.index ?? 0) + found[0].length;
+  }
+  const clause = text.slice(clauseStart);
+  let bestEnd = -1;
+  let best = "unknown";
+  const consider = (end, subject) => {
+    if (end > bestEnd) {
+      bestEnd = end;
+      best = subject;
+    }
+  };
+  for (const found of clause.matchAll(SUBJECT_PRONOUN)) {
+    const end = (found.index ?? 0) + found[0].length;
+    if (OBSERVER_PRONOUNS.has(found[0]) && OBSERVATION_VERB.test(clause.slice(end))) continue;
+    consider(end, SENDER_PRONOUNS.has(found[1]) ? "sender" : "recipient");
+  }
+  const nameHits = (list, subject) => {
+    for (const name of list ?? []) {
+      const needle = normalizeForQuote(name);
+      if (needle.length < 2) continue;
+      for (const at of wholeSpansOf(clause, needle)) consider(at + needle.length, subject);
+    }
+  };
+  nameHits(names.senderNames, "sender");
+  nameHits(names.recipientNames, "recipient");
+  return best;
+}
+var FIRST_PERSON_FIRM = /(?<![\p{L}'’])[Ii](?:['’](?:ve|ll|d|m))?\s+(?:(?:have|will|would|can|could|also|personally|just|recently|already|then|now|actually|really)\s+){0,2}(?:build|builds|built|building|design|designs|designed|designing|offer|offers|offered|offering|work with|worked with|working with|put together|deliver|delivers|delivered|delivering)(?![\p{L}])/gu;
+function quotedRanges(text) {
+  const ranges = [];
+  for (const found of text.matchAll(/"[^"\n]*"|“[^”\n]*”|(?:https?:\/\/|www\.)\S+|[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g)) {
+    ranges.push([found.index ?? 0, (found.index ?? 0) + found[0].length]);
+  }
+  return ranges;
+}
+function findFirstPersonFirm(text) {
+  const source = typeof text === "string" ? text : "";
+  const quoted = quotedRanges(source);
+  const hits = [];
+  for (const found of source.matchAll(FIRST_PERSON_FIRM)) {
+    const index = found.index ?? 0;
+    if (quoted.some(([s, e]) => index >= s && index < e)) continue;
+    hits.push({ index, match: found[0] });
+  }
+  return hits;
+}
+function partOf(lines, firstOrder, split) {
+  const sentences = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    for (const text of split ? splitSentences(trimmed) : [trimmed]) {
+      sentences.push({ text, clean: text.normalize("NFKC").replace(INVISIBLE, ""), norm: foldMatchable(text), order: firstOrder + sentences.length });
+    }
+  }
+  const starts = [];
+  let at = 0;
+  for (const s of sentences) {
+    starts.push(at);
+    at += s.norm.length + 1;
+  }
+  return { sentences, joined: sentences.map((s) => s.norm).join(" "), starts };
+}
+function sentenceAt(part, index) {
+  let found = null;
+  for (let i = 0; i < part.sentences.length; i++) {
+    if (part.starts[i] <= index) found = part.sentences[i];
+    else break;
+  }
+  return found;
+}
+var LETTER2 = /\p{L}/gu;
+var letterCount = (text) => (text.match(LETTER2) ?? []).length;
+var quoteMatch = (match) => `"${match}"`;
+function claimNorm(text) {
+  return typeof text === "string" ? normalizeForQuote(text) : "";
+}
+function attachesTo(claim, sentence) {
+  if (!claim || !sentence) return false;
+  if (claim === sentence) return true;
+  if (claim.length >= 8 && wholeSpanAt(sentence, claim) >= 0) return true;
+  return sentence.length >= 8 && wholeSpanAt(claim, sentence) >= 0;
+}
+function checkOutboundCopy(copy, ctx) {
+  const author = OUTBOUND_AUTHORS.includes(ctx?.author) ? ctx.author : "agent";
+  const agent = author === "agent";
+  const operator = author === "operator";
+  const format = copy?.format === "html" ? "html" : "text";
+  const channel = copy?.channel === "sms" ? "sms" : "email";
+  const rules = ctx?.rules ?? null;
+  const mode = ctx?.numbers ?? (agent ? "present" : "cited");
+  const senderNames = rules?.sender_names ?? [];
+  const recipientNames = ctx?.recipient?.names ?? [];
+  const subjectNames = { senderNames, recipientNames };
+  const primary = normalizeForQuote(ctx?.evidence?.primary ?? "");
+  const primaryNumbers = new Set(numbersIn(primary));
+  const primaryAmounts = moneyAmounts(primary);
+  const facts = /* @__PURE__ */ new Map();
+  for (const fact of rules?.facts ?? []) if (fact && typeof fact.id === "string") facts.set(fact.id, fact);
+  const verifiedFactNumbers = /* @__PURE__ */ new Set();
+  for (const fact of facts.values()) if (fact.verified) for (const n of numbersIn(normalizeForQuote(fact.text))) verifiedFactNumbers.add(n);
+  const published = (rules?.prices ?? []).flatMap((price) => priceMentionsIn(normalizeForQuote(price?.display ?? "")));
+  const publishedDisplays = (rules?.prices ?? []).map((price) => price?.display).filter((d) => typeof d === "string" && !!d.trim());
+  const plain = outboundPlainText(copy?.body ?? "", format);
+  const subjectText = channel === "email" ? decodeHtmlEntities(typeof copy?.subject === "string" ? copy.subject : "") : "";
+  const subjectPart = partOf(subjectText ? [subjectText] : [], 0, false);
+  const bodyPart = partOf(plain.split("\n"), subjectPart.sentences.length, true);
+  const parts = [subjectPart, bodyPart];
+  const sentences = [...subjectPart.sentences, ...bodyPart.sentences];
+  const found = { blocking: [], flags: [], style: [] };
+  const seen = /* @__PURE__ */ new Set();
+  const add = (bucket, sentence, pos, code, match, extra = {}) => {
+    if (bucket === "flags" && operator) return;
+    const finding = makeOutboundFinding(code, sentence?.text ?? "", match, extra);
+    const key = `${bucket}:${finding.id}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    found[bucket].push({ order: sentence?.order ?? -1, pos, finding });
+  };
+  if (channel === "email" && !/[\p{L}\p{N}]/u.test(subjectText)) add("blocking", null, 0, "empty_subject", "");
+  const letters = letterCount(plain);
+  if (channel === "sms" ? letters === 0 : letters < 8) {
+    add("blocking", null, 0, "empty_body", "", channel === "sms" ? { reason: "The text has no words in it." } : { reason: "The email has almost nothing in it." });
+  }
+  for (const part of parts) {
+    for (const hit of tokenHits(part.joined)) {
+      add("blocking", sentenceAt(part, hit.index), hit.index, "unrendered_token", hit.match, {
+        reason: `${quoteMatch(hit.match)} is a placeholder that was never filled in.`
+      });
+    }
+    for (const hit of platformHits(part.joined)) {
+      const sentence = sentenceAt(part, hit.index);
+      if (hit.negated) {
+        add("flags", sentence, hit.index, "banned_claim_negated", hit.match, {
+          reason: `It brings up ${PLATFORM_CLAIM_NAME[hit.id]} while saying it can't promise it.`
+        });
+      } else {
+        add("blocking", sentence, hit.index, "platform_banned_claim", hit.match, { reason: PLATFORM_CLAIM_REASON[hit.id] });
+      }
+    }
+    if (rules) {
+      for (const hit of phraseHits(part.joined, rules.banned)) {
+        add("blocking", sentenceAt(part, hit.index), hit.index, "project_banned_claim", hit.match, {
+          reason: `It says ${quoteMatch(hit.phrase)}, which the Business Brief says never to claim.`
+        });
+      }
+      for (const hit of phraseHits(part.joined, rules.forbidden)) {
+        add("blocking", sentenceAt(part, hit.index), hit.index, "forbidden_phrase", hit.match, {
+          reason: `It says ${quoteMatch(hit.phrase)}, which this outreach angle never says.`
+        });
+      }
+    }
+  }
+  if (agent && format === "html") {
+    for (const hit of findUnsafeMarkup(copy?.body ?? "")) {
+      add("blocking", null, hit.index, "unsafe_markup", hit.match, { reason: `The HTML has ${hit.match}, which email clients strip or flag as spam.` });
+    }
+  }
+  const claims = (ctx?.claims ?? []).filter((c) => !!c && typeof c === "object" && typeof c.text === "string");
+  const claimsBySentence = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    const norm = claimNorm(claim.text);
+    for (const sentence of sentences) {
+      if (!attachesTo(norm, sentence.norm)) continue;
+      const list = claimsBySentence.get(sentence) ?? [];
+      list.push(claim);
+      claimsBySentence.set(sentence, list);
+    }
+  }
+  const isResearch = (claim) => "evidence" in claim && claim.evidence === "research";
+  const factOf = (claim) => {
+    const id = "fact_id" in claim ? claim.fact_id : null;
+    return typeof id === "string" ? facts.get(id) ?? null : null;
+  };
+  const validFactClaims = (list) => list.filter((c) => !isResearch(c) && factOf(c)?.verified === true);
+  const recipientResearchNumbers = /* @__PURE__ */ new Set();
+  for (const sentence of [...bodyPart.sentences, ...subjectPart.sentences]) {
+    const attached = claimsBySentence.get(sentence) ?? [];
+    const researchCited = attached.some(isResearch);
+    const factClaims = validFactClaims(attached);
+    const brokenCitation = attached.some((c) => !isResearch(c) && typeof ("fact_id" in c ? c.fact_id : null) === "string" && factOf(c)?.verified !== true);
+    for (const claim of attached) {
+      const id = !isResearch(claim) && "fact_id" in claim ? claim.fact_id : null;
+      if (typeof id !== "string") continue;
+      const fact = facts.get(id);
+      if (fact?.verified === true) continue;
+      add("flags", sentence, 0, "citation_invalid", id, {
+        reason: fact ? `It cites ${id}, which nobody has verified yet.` : `It cites ${id}, which isn't in the Business Brief.`,
+        fact_id: id
+      });
+    }
+    if (rules) {
+      for (const mention of priceMentionsIn(sentence.norm)) {
+        const factBacked = factClaims.some((c) => priceMentionsIn(normalizeForQuote(factOf(c).text)).some((p) => samePrice(p, mention)));
+        if (factBacked || published.some((p) => samePrice(p, mention))) continue;
+        const subject = claimSubjectOf(sentence.norm, mention.index, subjectNames);
+        const amounts = mention.amounts.map(amountValue);
+        const inPrimary = amounts.length > 0 && amounts.every((a) => primaryAmounts.some((p) => sameAmount(p, a)));
+        const researchBacked = researchCited || mode === "present" && inPrimary;
+        if (researchBacked && (subject === "recipient" || subject === "unknown" && inPrimary)) {
+          if (inPrimary) {
+            if (agent && mode === "present") add("flags", sentence, mention.index, "number_from_research", mention.match, { reason: `${quoteMatch(mention.match)} comes from the research about the recipient.` });
+            continue;
+          }
+          add("flags", sentence, mention.index, "citation_mismatch", mention.match, { reason: `${quoteMatch(mention.match)} isn't in the research it cites.` });
+        } else if (researchBacked) {
+          add("flags", sentence, mention.index, "citation_wrong_source", mention.match, {
+            reason: `${quoteMatch(mention.match)} is a claim about the sender, but only research about the recipient backs it.`
+          });
+        }
+        const oneEnd = mention.shape !== "range" && published.some((p) => p.shape === "range" && (sameAmount(p.min, mention.min) || sameAmount(p.max, mention.max)));
+        const shown = publishedDisplays.slice(0, 3).join("; ");
+        if (rules.prices_known) {
+          add("blocking", sentence, mention.index, "price_mismatch", mention.match, {
+            reason: oneEnd ? `${quoteMatch(mention.match)} is only one end of a published range.` : `${quoteMatch(mention.match)} doesn't match a price you've published.`,
+            fix: shown ? `Use the price exactly as published (${shown}), or leave the price out.` : "Use the price as published, or leave the price out."
+          });
+        } else {
+          add("flags", sentence, mention.index, "price_unverifiable", mention.match, { reason: `${quoteMatch(mention.match)} isn't a published price, so it can't be checked.` });
+        }
+      }
+    }
+    if (!operator) {
+      const subjectLine = sentence.order < subjectPart.sentences.length;
+      for (const number of claimNumbersIn(sentence.norm, !!rules)) {
+        const subject = claimSubjectOf(sentence.norm, number.index, subjectNames);
+        const recipient = subject === "recipient";
+        if (factClaims.some((c) => numbersIn(normalizeForQuote(factOf(c).text)).includes(number.value))) continue;
+        if (researchCited) {
+          const readsAsRecipient = recipient || subject === "unknown" && primaryNumbers.has(number.value);
+          if (readsAsRecipient && primaryNumbers.has(number.value)) recipientResearchNumbers.add(number.value);
+          if (!readsAsRecipient) {
+            add("flags", sentence, number.index, "citation_wrong_source", number.match, {
+              reason: `${quoteMatch(number.match)} is a claim about the sender, but only research about the recipient backs it.`
+            });
+          } else if (!primaryNumbers.has(number.value)) {
+            add("flags", sentence, number.index, "citation_mismatch", number.match, { reason: `${quoteMatch(number.match)} isn't in the research it cites.` });
+          }
+          continue;
+        }
+        if (factClaims.length) {
+          add("flags", sentence, number.index, "citation_mismatch", number.match, { reason: `${quoteMatch(number.match)} isn't in the fact it cites.` });
+          continue;
+        }
+        if (brokenCitation) continue;
+        if (subjectLine && subject !== "sender" && recipientResearchNumbers.has(number.value)) continue;
+        if (mode === "present") {
+          if (verifiedFactNumbers.has(number.value)) continue;
+          if (primaryNumbers.has(number.value)) {
+            if (recipient) {
+              if (agent) add("flags", sentence, number.index, "number_from_research", number.match, { reason: `${quoteMatch(number.match)} comes from the research about the recipient.` });
+            } else {
+              add("flags", sentence, number.index, "citation_wrong_source", number.match, {
+                reason: `${quoteMatch(number.match)} is a claim about the sender, but only research about the recipient backs it.`
+              });
+            }
+            continue;
+          }
+        }
+        add("flags", sentence, number.index, "unsupported_number", number.match, {
+          reason: `Nothing on record backs up ${quoteMatch(number.match)}.`,
+          fix: recipient ? "Back it with the research about them, or take it out." : "Cite a verified fact from the Business Brief, or take the number out."
+        });
+      }
+    }
+    if (isWriterNote(sentence.text)) add("flags", sentence, 0, "writer_note", sentence.norm);
+    for (const hit of findMixedScript(sentence.clean)) {
+      add("blocking", sentence, hit.index, "mixed_script", hit.match, { reason: `${quoteMatch(hit.match)} mixes letters from two alphabets, so it only looks like a normal word.` });
+    }
+    for (const hit of findDashes(sentence.clean)) {
+      add(agent ? "blocking" : "style", sentence, hit.index, "dash", hit.match, {
+        reason: hit.kind === "em" ? "It uses an em dash." : "It uses an en dash between words."
+      });
+    }
+    const protectedRanges = quotedRanges(sentence.clean);
+    for (const hit of findUncontracted(sentence.clean, { protectedRanges, titleLike: sentence.order < subjectPart.sentences.length })) {
+      add("style", sentence, hit.index, "uncontracted", hit.match, { reason: `${quoteMatch(hit.match)} reads stiff.`, fix: `Try ${quoteMatch(hit.suggestion)}.` });
+    }
+    for (const hit of findFirstPersonFirm(sentence.clean)) {
+      add("style", sentence, hit.index, "first_person_firm", hit.match, { reason: `${quoteMatch(hit.match)} says I for work the business does.` });
+    }
+  }
+  const sorted = (bucket) => found[bucket].sort((a, b) => a.order - b.order || a.pos - b.pos).map((x) => x.finding);
+  return { blocking: sorted("blocking"), flags: sorted("flags"), style: sorted("style"), plain };
+}
+var OUTBOUND_AUDIT_STATUSES = ["clean", "flagged", "not_run", "not_needed", "stale"];
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var isString = (value) => typeof value === "string";
+var isStringList = (value) => Array.isArray(value) && value.every(isString);
+function readFinding(value) {
+  if (!isRecord(value)) return null;
+  const { id, code, sentence, match, reason, fix, fact_id } = value;
+  if (!isString(id) || !id || !isString(code) || !/^[a-z_]{1,48}$/.test(code)) return null;
+  if (!isString(sentence) || !isString(match) || !isString(reason) || !isString(fix)) return null;
+  if (fact_id !== void 0 && fact_id !== null && !isString(fact_id)) return null;
+  const finding = { id, code, sentence, match, reason, fix };
+  if (isString(fact_id)) finding.fact_id = fact_id;
+  return finding;
+}
+function readFindings(value) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    const finding = readFinding(item);
+    if (!finding) return null;
+    out.push(finding);
+  }
+  return out;
+}
+function readRules(value) {
+  if (value === null) return null;
+  if (!isRecord(value)) return void 0;
+  const { prices, prices_known, banned, forbidden, facts, sender_names } = value;
+  if (!Array.isArray(prices) || typeof prices_known !== "boolean" || !isStringList(banned) || !isStringList(forbidden)) return void 0;
+  const readPrices = [];
+  for (const price of prices) {
+    if (!isRecord(price) || !isString(price.display)) return void 0;
+    readPrices.push(isString(price.fact_id) ? { display: price.display, fact_id: price.fact_id } : { display: price.display });
+  }
+  const rules = { prices: readPrices, prices_known, banned: [...banned], forbidden: [...forbidden] };
+  if (facts !== void 0) {
+    if (!Array.isArray(facts)) return void 0;
+    const readFacts = [];
+    for (const fact of facts) {
+      if (!isRecord(fact) || !isString(fact.id) || !isString(fact.text) || typeof fact.verified !== "boolean") return void 0;
+      readFacts.push({ id: fact.id, text: fact.text, verified: fact.verified });
+    }
+    rules.facts = readFacts;
+  }
+  if (sender_names !== void 0) {
+    if (!isStringList(sender_names)) return void 0;
+    rules.sender_names = [...sender_names];
+  }
+  return rules;
+}
+function readOutboundClaimReview(value) {
+  if (!isRecord(value) || value.version !== 1) return null;
+  const { checked_at, author, brain_version, audit, acknowledged, asserted } = value;
+  if (!isString(checked_at) || !OUTBOUND_AUTHORS.includes(author)) return null;
+  if (brain_version !== null && brain_version !== void 0 && (typeof brain_version !== "number" || !Number.isFinite(brain_version))) return null;
+  const rules = readRules(value.rules ?? null);
+  if (rules === void 0) return null;
+  const flags = readFindings(value.flags);
+  const style = readFindings(value.style ?? []);
+  if (!flags || !style) return null;
+  if (!isRecord(audit) || !OUTBOUND_AUDIT_STATUSES.includes(audit.status)) return null;
+  let ack = null;
+  if (acknowledged !== null && acknowledged !== void 0) {
+    if (!isRecord(acknowledged) || !isString(acknowledged.by) || !isString(acknowledged.at) || !isString(acknowledged.via) || !isStringList(acknowledged.flag_ids)) return null;
+    ack = { by: acknowledged.by, at: acknowledged.at, via: acknowledged.via, flag_ids: [...acknowledged.flag_ids] };
+  }
+  let assertion = null;
+  if (asserted !== null && asserted !== void 0) {
+    if (!isRecord(asserted) || !isString(asserted.by) || !isString(asserted.at) || !isStringList(asserted.flag_ids)) return null;
+    assertion = { by: asserted.by, at: asserted.at, flag_ids: [...asserted.flag_ids] };
+  }
+  return {
+    version: 1,
+    checked_at,
+    author,
+    brain_version: typeof brain_version === "number" ? brain_version : null,
+    rules,
+    flags,
+    style,
+    audit: { ...audit, status: audit.status },
+    acknowledged: ack,
+    asserted: assertion
+  };
+}
+function unsettledFlags(review) {
+  const settled = new Set(review.acknowledged?.flag_ids ?? []);
+  if (review.author === "agent") for (const id of review.asserted?.flag_ids ?? []) settled.add(id);
+  return review.flags.filter((flag) => !settled.has(flag.id));
+}
+function withoutDashChars(text) {
+  return text.replace(/[—―⸺⸻]/g, "[em dash]").replace(/[‒–]/g, "[en dash]");
+}
+function clip(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= max) return flat;
+  const cut = flat.slice(0, max);
+  const space = cut.lastIndexOf(" ");
+  return `${space > max * 0.6 ? cut.slice(0, space) : cut}...`;
+}
+function outboundRefusalMessage(findings) {
+  const list = (findings ?? []).filter(Boolean);
+  if (!list.length) return "";
+  const head = list.length === 1 ? "This can't go out yet. Fix this and try again:" : `This can't go out yet. Fix these ${list.length} things and try again:`;
+  const lines = list.map((f, i) => {
+    const where = f.sentence && f.sentence.trim() ? ` (In: "${clip(f.sentence, 160)}")` : "";
+    return `${i + 1}. ${f.reason} ${f.fix}${where}`;
+  });
+  return withoutDashChars([head, ...lines].join("\n"));
+}
+function readBackPlain(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return outboundPlainText(value, /<\/?[a-z][a-z0-9]*\b[^>]*>/i.test(value) ? "html" : "text");
+  if (typeof value.body !== "string") return null;
+  return outboundPlainText(value.body, value.format ?? (/<\/?[a-z][a-z0-9]*\b[^>]*>/i.test(value.body) ? "html" : "text"));
+}
+function urlsIn(plain) {
+  const urls = (plain.match(/\b(?:https?:\/\/|www\.)[^\s<>"')\]]+/gi) ?? []).map((u) => u.replace(/[.,;:!?]+$/, ""));
+  return Array.from(new Set(urls));
+}
+function readBackVerdict(intended, read) {
+  const intendedPlain = readBackPlain(intended) ?? "";
+  const intendedNorm = foldMatchable(intendedPlain);
+  const readPlain = readBackPlain(read);
+  if (readPlain === null) {
+    return { status: "unreadable", body_chars: 0, intended_chars: intendedNorm.length, chars_missing: intendedNorm.length, urls_missing: urlsIn(intendedPlain) };
+  }
+  const readNorm = foldMatchable(readPlain);
+  const urls_missing = urlsIn(intendedPlain).filter((url) => !readNorm.includes(foldMatchable(url)));
+  let matched = intendedNorm.length;
+  if (!readNorm.includes(intendedNorm)) {
+    let lo = 0;
+    let hi = intendedNorm.length;
+    while (lo < hi) {
+      const mid = Math.ceil((lo + hi) / 2);
+      if (readNorm.includes(intendedNorm.slice(0, mid))) lo = mid;
+      else hi = mid - 1;
+    }
+    matched = lo;
+  }
+  const verdict = {
+    body_chars: readNorm.length,
+    intended_chars: intendedNorm.length,
+    chars_missing: intendedNorm.length - matched,
+    urls_missing
+  };
+  if (letterCount(readPlain) < 8) return { status: "empty", ...verdict };
+  if (verdict.chars_missing === 0 && urls_missing.length === 0) return { status: "verified", ...verdict };
+  return { status: "mismatch", ...verdict };
+}
+
+exports.BUSINESS_CLAIMS_CONTRACT_VERSION = BUSINESS_CLAIMS_CONTRACT_VERSION;
+exports.MIN_QUOTE_CHARS = MIN_QUOTE_CHARS;
+exports.OUTBOUND_AUDIT_STATUSES = OUTBOUND_AUDIT_STATUSES;
+exports.OUTBOUND_AUTHORS = OUTBOUND_AUTHORS;
+exports.PLATFORM_BANNED_CLAIMS = PLATFORM_BANNED_CLAIMS;
+exports.PRICE_RANGE_AFTER = PRICE_RANGE_AFTER;
+exports.PRICE_RANGE_BEFORE = PRICE_RANGE_BEFORE;
+exports.checkOutboundCopy = checkOutboundCopy;
+exports.checkQuotedPrice = checkQuotedPrice;
+exports.claimSubjectOf = claimSubjectOf;
+exports.decodeHtmlEntities = decodeHtmlEntities;
+exports.findDashes = findDashes;
+exports.findFirstPersonFirm = findFirstPersonFirm;
+exports.findMixedScript = findMixedScript;
+exports.findPhrases = findPhrases;
+exports.findPlatformBannedClaims = findPlatformBannedClaims;
+exports.findPriceMentions = findPriceMentions;
+exports.findUnrenderedTokens = findUnrenderedTokens;
+exports.findUnsafeMarkup = findUnsafeMarkup;
+exports.findUnsupportedNumbers = findUnsupportedNumbers;
+exports.fnv1a = fnv1a;
+exports.isWriterNote = isWriterNote;
+exports.makeOutboundFinding = makeOutboundFinding;
+exports.moneyAmounts = moneyAmounts;
+exports.normalizeForQuote = normalizeForQuote;
+exports.normalizeMatchable = normalizeMatchable;
+exports.numbersGrounded = numbersGrounded;
+exports.numbersIn = numbersIn;
+exports.outboundFindingId = outboundFindingId;
+exports.outboundPlainText = outboundPlainText;
+exports.outboundRefusalMessage = outboundRefusalMessage;
+exports.quoteFoundIn = quoteFoundIn;
+exports.readBackVerdict = readBackVerdict;
+exports.readOutboundClaimReview = readOutboundClaimReview;
+exports.removeDashes = removeDashes;
+exports.unsettledFlags = unsettledFlags;
+exports.wholeSpanAt = wholeSpanAt;