mcp-recipes 1.0.0 → 1.2.0

package/dist/index.js

@@ -7,7 +7,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/version.ts
-var PKG_VERSION = "1.0.0";
+var PKG_VERSION = "1.2.0";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -379,6 +379,15 @@ var MARMITON_PROFILE = {
 };
 var SITE_URL2 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
 var REFERENCE = /^\d+$/;
+async function readSearch(reader, query) {
+  try {
+    return await reader.search(query);
+  } catch (error) {
+    const code = error?.code;
+    if (code === "not_found") return { data: [], cached: false };
+    throw error;
+  }
+}
 function marmitonAdapter(reader) {
   return {
     ...MARMITON_PROFILE,
@@ -396,7 +405,7 @@ function marmitonAdapter(reader) {
       return null;
     },
     async search(query) {
-      const outcome = await reader.search(query);
+      const outcome = await readSearch(reader, query);
       const list = rowsOf(outcome.data, MARMITON_PROFILE);
       const rows = [];
       let skipped = 0;
@@ -748,6 +757,12 @@ var FRENCH_UNITS = {
   millilitres: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
   centilitre: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
   centilitres: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  // A page glossing a metric weight names the pound, which French writes as a
+  // livre: "450 g (1 livre) de spaghetti".
+  livre: { canonical: "livre", kind: "measured", system: "imperial", plural: "livres" },
+  livres: { canonical: "livre", kind: "measured", system: "imperial", plural: "livres" },
+  lb: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
+  lbs: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
   // Spoons and cups: real measures, but only in sensible fractions.
   "cuillere a soupe": {
     canonical: "cuill\xE8re \xE0 soupe",
@@ -959,6 +974,11 @@ var ENGLISH_UNITS = {
   leaf: { canonical: "leaf", kind: "portioned", system: "none", plural: "leaves" },
   leaves: { canonical: "leaf", kind: "portioned", system: "none", plural: "leaves" },
   ea: { canonical: "ea", kind: "portioned", system: "none", symbol: true },
+  // A dish of the book standing as an ingredient of another: "1 recipe Flaky
+  // Pie Crust". The count is what the word measures, so the plural mark belongs
+  // on it and not on the name of the dish.
+  recipe: { canonical: "recipe", kind: "portioned", system: "none", plural: "recipes" },
+  recipes: { canonical: "recipe", kind: "portioned", system: "none", plural: "recipes" },
   // Held to no better than a hand: the count scales, the size of one does not.
   // `readContainerLoad` explains what else lands here.
   capful: { canonical: "capful", kind: "approximate", system: "none", plural: "capfuls" },
@@ -1025,7 +1045,7 @@ function buildEmbedded(language) {
   return new RegExp(`\\d[\\d.,/]*\\s*(?:${keys.join("|")})\\b`, "i");
 }
 function hasEmbeddedMeasure(text2, language) {
-  return EMBEDDED[language].test(text2);
+  return EMBEDDED[language].test(normalizeUnitKey(text2));
 }
 var NOT_A_MEASURE = /* @__PURE__ */ new Set([
   "peu",
@@ -1148,9 +1168,10 @@ function isSpoonMeasure(unit) {
   );
 }
 function unitDivisibility(unit) {
+  if (unit.kind === "approximate") return "whole";
   return QUARTERED_MEASURE.test(unit.canonical) ? "quarter" : "half";
 }
-var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|gousses?|tranches?|slices?)\b/i;
+var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|tranches?|slices?)\b/i;
 function countsBarePieces(unit) {
   return unit.canonical === "ea";
 }
@@ -1202,6 +1223,103 @@ var VULGAR_FRACTIONS = {
   "\u215E": 0.875
 };
 var VULGAR_CLASS = Object.keys(VULGAR_FRACTIONS).join("");
+var NAMED_ENTITIES = {
+  frac12: "\xBD",
+  frac13: "\u2153",
+  frac23: "\u2154",
+  frac14: "\xBC",
+  frac34: "\xBE",
+  frac15: "\u2155",
+  frac18: "\u215B",
+  nbsp: " ",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  deg: "\xB0",
+  times: "\xD7",
+  minus: "\u2212",
+  ndash: "\u2013",
+  mdash: "\u2014"
+};
+function decodeEntities(text2) {
+  return text2.replace(/&#x([0-9a-f]+);/gi, (whole, hex) => codePoint(parseInt(hex, 16), whole)).replace(/&#(\d+);/g, (whole, digits) => codePoint(Number(digits), whole)).replace(
+    /&([a-z][a-z0-9]*);/gi,
+    (whole, name) => NAMED_ENTITIES[name.toLowerCase()] ?? whole
+  );
+}
+function codePoint(value, published) {
+  if (!Number.isInteger(value) || value < 32 || value > 1114111) return published;
+  try {
+    return String.fromCodePoint(value);
+  } catch {
+    return published;
+  }
+}
+var EMPTY_BRACKETS = /\(\s*\)/g;
+function readable(text2) {
+  return decodeEntities(text2).replace(EMPTY_BRACKETS, " ").replace(/\s+/g, " ").trim();
+}
+var APPROXIMATION_PREFIX = {
+  en: /^(?:~|\u2248|about|approx\.?|approximately|around|roughly)\s*/i,
+  fr: /^(?:~|\u2248|environ|approximativement|\u00e0 peu pr\u00e8s|a peu pres)\s*/i
+};
+var CONTAINER_CONTENTS = /^\s*(?:de\s|d'|du\s|des\s)/i;
+function statesItemSize(item) {
+  const attached = /\s+de\s+(?=\d)/i.exec(item);
+  if (!attached) return false;
+  const named = item.slice(0, attached.index).trim();
+  if (!named || /\d/.test(named)) return false;
+  return isStatedSize(item.slice(attached.index + attached[0].length));
+}
+function isStatedSize(text2) {
+  const size = parseLeadingQuantity(text2, "fr");
+  if (!size) return false;
+  const measure = takeUnit(text2.slice(size.length).trimStart(), "fr");
+  if (!measure.unit || measure.unit.kind !== "measured") return false;
+  return !CONTAINER_CONTENTS.test(measure.rest);
+}
+var PER_PERSON = {
+  en: /\bper\s+(?:person|head|serving|guest|diner)\b/i,
+  fr: /\bpar\s+(?:personne|convive|part|t\u00eate)\b/i
+};
+var MEASURE_ADJECTIVES = {
+  en: /* @__PURE__ */ new Set([
+    "big",
+    "generous",
+    "good",
+    "heaped",
+    "heaping",
+    "large",
+    "level",
+    "medium",
+    "scant",
+    "small"
+  ]),
+  fr: /* @__PURE__ */ new Set([
+    "beau",
+    "belle",
+    "bon",
+    "bonne",
+    "grand",
+    "grande",
+    "gros",
+    "grosse",
+    "petit",
+    "petite"
+  ])
+};
+function takeMeasureAdjective(text2, language) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+", "u").exec(text2);
+  if (!match) return { adjective: null, rest: text2 };
+  const folded = normalizeUnitKey(match[1]);
+  const listed = MEASURE_ADJECTIVES[language].has(folded) || MEASURE_ADJECTIVES[language].has(folded.replace(/s$/, ""));
+  if (!listed) return { adjective: null, rest: text2 };
+  return { adjective: match[1], rest: text2.slice(match[0].length) };
+}
+var COMMA_GROUPED = /^\s*\d{1,3}(?:,\d{3})+(?!\d)/;
+var COMMA_DECIMAL = /^\s*\d+,\d+/;
 function parseLeadingQuantity(text2, language) {
   const trimmed = text2.trimStart();
   const offset = text2.length - trimmed.length;
@@ -1307,21 +1425,25 @@ function takeUnitEitherLanguage(text2, language) {
   if (first.unit) return first;
   return takeUnit(text2, language === "fr" ? "en" : "fr");
 }
-function detectLanguage(line) {
+function readEvidence(line) {
   const text2 = line.trim();
   const afterFigures = text2.replace(/^[\s\d.,/½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞\-–—]+/u, "").trimStart();
   const afterArticle = afterFigures.replace(/^(?:un|une|quelques|of\s+an?|an?)\s+/iu, "");
   const frenchUnit = takeUnit(afterArticle, "fr").unit !== null;
   const englishUnit = takeUnit(afterArticle, "en").unit !== null;
-  return readLanguage(text2, { frenchUnit, englishUnit }).language;
+  return readLanguage(text2, { frenchUnit, englishUnit });
 }
 function parseIngredient(line, choice = "auto") {
   const original = line;
-  const text2 = line.trim();
-  const language = choice === "auto" ? detectLanguage(text2) : choice;
-  const empty = {
+  const text2 = readable(line);
+  const evidence = readEvidence(text2);
+  const language = choice === "auto" ? evidence.language : choice;
+  const empty = (heldBack) => ({
     original,
     language,
+    heldBack,
+    approximation: null,
+    measureAdjective: null,
     amount: null,
     amountMax: null,
     rangeSeparator: null,
@@ -1331,25 +1453,39 @@ function parseIngredient(line, choice = "auto") {
     item: text2,
     articleWord: null,
     countMultiplier: null
-  };
-  const range = parseLeadingRange(text2, language);
-  const article = range ? null : readArticle(text2, language);
-  const quantity = range ?? parseLeadingQuantity(text2, language) ?? article;
-  if (!quantity) return empty;
-  let rest = text2.slice(quantity.length).trimStart();
+  });
+  if (unreadableComma(text2, language, evidence)) return empty("ambiguousDecimal");
+  const loose = APPROXIMATION_PREFIX[language].exec(text2);
+  const stated = loose ? text2.slice(loose[0].length) : text2;
+  const range = parseLeadingRange(stated, language);
+  const article = range ? null : readArticle(stated, language);
+  const quantity = range ?? parseLeadingQuantity(stated, language) ?? article;
+  if (!quantity) return empty(null);
+  if (new RegExp("^-\\p{L}", "u").test(stated.slice(quantity.length))) return empty("sizeQualifier");
+  let rest = stated.slice(quantity.length).trimStart();
   if (language === "en") rest = rest.replace(/^(?:of\s+)?an?\s+/i, "");
   const multiplier = readCountMultiplier(rest);
   if (multiplier) rest = multiplier.rest;
   const times = multiplier?.times ?? 1;
-  const leading = takeLeadingUnit(rest, language, quantity === article);
+  const fromArticle = quantity === article;
+  const direct = takeLeadingUnit(rest, language, fromArticle);
+  const described = direct.unit ? { adjective: null, rest } : takeMeasureAdjective(rest, language);
+  const behind = described.adjective ? takeLeadingUnit(described.rest, language, fromArticle) : null;
+  const leading = direct.unit ? direct : behind?.unit ? behind : direct;
   rest = leading.rest;
   const bracketed = takeAlternates(rest, language);
   rest = bracketed.rest;
   const slashed = bracketed.measures.length > 0 ? null : takeSlashAlternates(rest, language);
   if (slashed) rest = slashed.rest;
+  const item = stripItemLead(rest, language);
+  if (language === "fr" && !leading.unit && statesItemSize(item)) return empty("itemSize");
+  if (language === "fr" && leading.partitive && isStatedSize(item)) return empty("itemSize");
   return {
     original,
     language,
+    heldBack: PER_PERSON[language].test(text2) ? "perPerson" : null,
+    approximation: loose ? loose[0] : null,
+    measureAdjective: behind?.unit ? described.adjective : null,
     amount: quantity.amount * times,
     amountMax: range === null ? null : range.max * times,
     rangeSeparator: range?.separator ?? null,
@@ -1357,10 +1493,18 @@ function parseIngredient(line, choice = "auto") {
     alternates: slashed ? slashed.measures : bracketed.measures,
     alternateStyle: slashed ? "slash" : bracketed.measures.length > 0 ? "bracket" : null,
     item: stripItemLead(rest, language),
-    articleWord: quantity === article ? article?.word ?? null : null,
+    articleWord: fromArticle ? article?.word ?? null : null,
     countMultiplier: multiplier?.times ?? null
   };
 }
+function unreadableComma(text2, language, evidence) {
+  if (COMMA_GROUPED.test(text2)) {
+    const settled = evidence.french !== evidence.english;
+    return !settled;
+  }
+  if (language === "en") return COMMA_DECIMAL.test(text2);
+  return /^\s*\d+,\d+,\d/.test(text2);
+}
 function readArticle(text2, language) {
   const counts = (rest) => takeLeadingUnit(rest, language, true).unit !== null || readCountMultiplier(rest) !== null;
   if (language === "fr") {
@@ -1390,12 +1534,12 @@ function readCountMultiplier(text2) {
 }
 function takeLeadingUnit(text2, language, fromArticle) {
   const taken = takeUnit(text2, language);
-  if (taken.unit) return taken;
+  if (taken.unit) return { ...taken, partitive: false };
   if (language === "fr" && fromArticle) {
     const measure = readPartitiveMeasure(text2);
-    if (measure) return { unit: measure.unit, rest: measure.rest };
+    if (measure) return { unit: measure.unit, rest: measure.rest, partitive: true };
   }
-  return taken;
+  return { ...taken, partitive: false };
 }
 function stripItemLead(text2, language) {
   if (language === "fr") {
@@ -1556,7 +1700,7 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
   const inUnit = (target, ratio) => ({
     bounds: raws.map((raw, index) => {
       const exact = raw * ratio;
-      const rounded = roundMeasured(exact);
+      const rounded = ratio < 1 ? Number((roundMeasured(raw) * ratio).toPrecision(12)) : roundMeasured(exact);
       const usable = rounded === 0 && exact > 0 ? Number(exact.toPrecision(2)) : rounded;
       const ceiling = factor < 1 ? sources[index] * ratio : Number.POSITIVE_INFINITY;
       return {
@@ -1590,7 +1734,7 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
   return { bounds, unit };
 }
 var PORTION_SIZED_ITEM = new RegExp(
-  "\\b(?:shrimps?|prawns?|langoustines?|mussels?|hazelnuts?|peppercorns?|junipers?|grains?|anise|crevettes?|gambas|moules?|noisettes?|geni\xE8vres?|genievres?|anis)\\b",
+  "\\b(?:shrimps?|prawns?|langoustines?|mussels?|hazelnuts?|peppercorns?|junipers?|grains?|anise|crevettes?|gambas|moules?|noisettes?|genievres?|genevriers?|badianes?|anis)\\b",
   "iu"
 );
 var QUARTERED_ITEM = new RegExp(
@@ -1603,7 +1747,7 @@ var HALVED_CUT = /\b(?:breasts?|thighs?|drumsticks?|wings?|cutlets?|cuisses?|ail
 function cloveDivisibility(unit, item) {
   const counted = unit ? unit.canonical === "clove" : /\bcloves?\b/i.test(item);
   if (!counted) return null;
-  return /\bgarlic\b/i.test(item) ? "quarter" : "whole";
+  return /\bgarlic\b/i.test(item) ? "half" : "whole";
 }
 var BLANC_OF = /\bblancs?\s+d(?:e\s|['’])/iu;
 var BLANC_OF_EGG = /\bblancs?\s+d(?:e\s|['’])\s*(?:oeufs?|œufs?)\b/iu;
@@ -1611,18 +1755,22 @@ function blancDivisibility(item) {
   if (!BLANC_OF.test(item)) return null;
   return BLANC_OF_EGG.test(item) ? "whole" : "half";
 }
+function foldItem(item) {
+  return item.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\u0153/g, "oe").replace(/\u0152/g, "OE");
+}
 function divisibilityOf(unit, item) {
-  const clove = cloveDivisibility(unit, item);
+  const key = foldItem(item);
+  const clove = cloveDivisibility(unit, key);
   if (clove) return clove;
   if (unit && !countsBarePieces(unit)) return unitDivisibility(unit);
-  const blanc = blancDivisibility(item);
+  const blanc = blancDivisibility(key);
   if (blanc) return blanc;
-  if (WHOLE_ITEM.test(item)) return "whole";
-  if (PORTION_SIZED_ITEM.test(item)) return "whole";
-  if (HALVED_ITEM.test(item)) return "half";
-  if (HALVED_CUT.test(item)) return "half";
-  if (QUARTERED_MEASURE.test(item)) return "quarter";
-  return QUARTERED_ITEM.test(item) ? "quarter" : "half";
+  if (WHOLE_ITEM.test(key)) return "whole";
+  if (PORTION_SIZED_ITEM.test(key)) return "whole";
+  if (HALVED_ITEM.test(key)) return "half";
+  if (HALVED_CUT.test(key)) return "half";
+  if (QUARTERED_MEASURE.test(key)) return "quarter";
+  return QUARTERED_ITEM.test(key) ? "quarter" : "half";
 }
 var INVARIABLE_ITEM = /* @__PURE__ */ new Set([
   "anise",
@@ -1789,6 +1937,8 @@ var AGREEABLE_ADJECTIVES = /* @__PURE__ */ new Set([
   "petite",
   "grand",
   "grande",
+  "gros",
+  "grosse",
   "mur",
   "mure",
   "vert",
@@ -1852,6 +2002,16 @@ function agreeInFrench(item, amount) {
   }
   return words.join(" ");
 }
+function agreeLeadingAdjective(word, amount, language) {
+  if (language === "en") return word;
+  const wantsPlural = amount >= 2;
+  const folded = foldWord(word);
+  const isPlural = folded.endsWith("s") && !AGREEABLE_ADJECTIVES.has(folded);
+  const singular = isPlural ? word.slice(0, -1) : word;
+  if (!AGREEABLE_ADJECTIVES.has(foldWord(singular))) return word;
+  if (wantsPlural === isPlural) return word;
+  return wantsPlural ? `${singular}s` : singular;
+}
 function agreeWithAmount(item, amount, language) {
   return language === "fr" ? agreeInFrench(item, amount) : agreeInEnglish(item, amount);
 }
@@ -1910,11 +2070,17 @@ function scaleAlternative(tail, options) {
   if (largest < 1) return { text: published, rewritten: false };
   return { text: scaleIngredient(tail, options).text, rewritten: true };
 }
+var HELD_BACK_NOTE = {
+  sizeQualifier: "The figures here give the size of one item rather than how many, so the line is left as published.",
+  itemSize: "The measure standing behind the item gives the size of one of them rather than how many, so the line is left as published. Serving more people is a matter of taking a bigger one, and serving fewer a smaller one.",
+  perPerson: "This line already states an amount for one person, and the factor is what changes how many people the recipe serves, so the line is left as published.",
+  ambiguousDecimal: "The comma in this number marks thousands in one convention and the decimal point in another, and the line gives no sign which was meant, so it is left as published."
+};
 function scaleSingleLine(line, options) {
   const { factor } = options;
   const parsed = parseIngredient(line, options.language ?? "auto");
   const language = parsed.language;
-  if (parsed.amount === null) {
+  if (parsed.amount === null || parsed.heldBack) {
     return {
       text: parsed.original,
       original: parsed.original,
@@ -1923,7 +2089,7 @@ function scaleSingleLine(line, options) {
       amountMax: null,
       unit: null,
       language,
-      note: "No quantity given; adjust to taste."
+      note: parsed.heldBack ? HELD_BACK_NOTE[parsed.heldBack] : "No quantity given; adjust to taste."
     };
   }
   const divisibility = divisibilityOf(parsed.unit, parsed.item);
@@ -1947,13 +2113,14 @@ function scaleSingleLine(line, options) {
     parsed.rangeSeparator
   );
   const named = unit && !countsBarePieces(unit) ? unit : null;
-  const unitLabel = named ? ` ${formatUnit(named, shown, language)}` : "";
+  const adjective = named && parsed.measureAdjective ? ` ${agreeLeadingAdjective(parsed.measureAdjective, shown, language)}` : "";
+  const unitLabel = named ? `${adjective} ${formatUnit(named, shown, language)}` : "";
   const alternateTexts = alternates.map((entry) => entry.text);
   const altLabel = alternates.length === 0 ? "" : parsed.alternateStyle === "slash" ? ` / ${alternateTexts.join(" / ")}` : ` (${alternateTexts.join(" / ")})`;
   const counted = agreeWithAmount(parsed.item, shown, language);
   const itemLabel = named ? joinItem(parsed.item, language) : counted ? ` ${counted}` : "";
   const result = {
-    text: `${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
+    text: `${parsed.approximation ?? ""}${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
     original: parsed.original,
     scaling: movedPrimary || movedAlternate || restated ? "rounded" : "scaled",
     amount: low.amount,
@@ -1996,6 +2163,11 @@ function scaleSingleLine(line, options) {
       "This is smaller than a kitchen scale resolves. Make a larger batch, or measure it by eye."
     );
   }
+  if (parsed.approximation) {
+    sentences.push(
+      "The page gave this amount as an approximation, and the scaled figure is no firmer."
+    );
+  }
   if (sentences.length > 0) result.note = sentences.join(" ");
   if (parsed.unit && parsed.unit.kind === "approximate") {
     result.note = withApproximateNote(parsed.unit, result.note);
@@ -2043,16 +2215,18 @@ function scaleIngredients(lines, options) {
 }
 function passthroughIngredient(line, language = "auto") {
   const parsed = parseIngredient(line, language);
+  const held = parsed.amount === null || parsed.heldBack !== null;
   const result = {
     text: parsed.original,
     original: parsed.original,
-    scaling: parsed.amount === null ? "unscaled" : "scaled",
-    amount: parsed.amount,
-    amountMax: parsed.amountMax,
-    unit: parsed.unit?.canonical ?? null,
+    scaling: held ? "unscaled" : "scaled",
+    amount: held ? null : parsed.amount,
+    amountMax: held ? null : parsed.amountMax,
+    unit: held ? null : parsed.unit?.canonical ?? null,
     language: parsed.language
   };
-  if (parsed.amount === null) result.note = "No quantity given; adjust to taste.";
+  if (parsed.heldBack) result.note = HELD_BACK_NOTE[parsed.heldBack];
+  else if (parsed.amount === null) result.note = "No quantity given; adjust to taste.";
   else if (parsed.unit?.kind === "approximate") {
     result.note = withApproximateNote(parsed.unit, void 0);
   }
@@ -2089,7 +2263,13 @@ var reportSchema = z.object({
     code: z.string(),
     message: z.string(),
     hint: z.string().optional()
-  }).nullable().describe("Why this source did not answer. Null when it did.")
+  }).nullable().describe("Why this source did not answer. Null when it did."),
+  read: z.object({
+    status: z.enum(["read", "failed"]),
+    error: z.object({ code: z.string(), message: z.string(), hint: z.string().optional() }).nullable()
+  }).nullable().describe(
+    "What became of the row this source offered, once it was opened. Null when no row was opened, which is what a search that did not answer and a search holding nothing both come to. A search and a read are two moments, and this is the second one."
+  )
 });
 var ingredientSchema = z.object({
   text: z.string().describe("The line as it now reads."),
@@ -2139,9 +2319,15 @@ function toReportPayload(report) {
     reported_total_means: report.reportedTotalMeans,
     skipped: report.skipped,
     cached: report.cached,
-    error: report.error ?? null
+    error: report.error ?? null,
+    // A search alone opens nothing, so only a tool that reads a row fills this
+    // in, through `withRead`.
+    read: null
   };
 }
+function withRead(payload, read) {
+  return { ...payload, read };
+}
 function reportNotes(reports) {
   const notes = [];
   const answered = reports.filter((report) => report.status === "answered");
@@ -2575,14 +2761,19 @@ async function runCompareRecipes(client, args) {
     const reads = await Promise.allSettled(offered.map(([, id]) => client.getRecipe(id)));
     const recipes = [];
     const unread = /* @__PURE__ */ new Map();
+    const opened = /* @__PURE__ */ new Set();
     reads.forEach((read, index) => {
       const source = offered[index][0];
+      opened.add(source);
       if (read.status === "fulfilled") {
         recipes.push(read.value.recipe);
         return;
       }
       const reason = read.reason;
-      unread.set(source, `${reason?.code ?? "network_error"}: ${reason?.message ?? "unknown"}`);
+      unread.set(source, {
+        code: reason?.code ?? "network_error",
+        message: reason?.message ?? "unknown"
+      });
     });
     const views = recipes.map(
       (recipe) => buildRecipeView(recipe, {
@@ -2610,11 +2801,15 @@ async function runCompareRecipes(client, args) {
       const failedRead = unread.get(report.source);
       if (report.status === "failed") {
         notes.push(
-          `${report.name} is missing from this comparison because its search did not answer, not because it holds nothing.`
+          `${report.name} is missing from this comparison because its search did not answer (${quoteForeign(
+            `${report.error?.code ?? "unknown"}: ${report.error?.message ?? "unknown"}`
+          )}). Nothing here is evidence about what it holds.`
         );
       } else if (failedRead) {
         notes.push(
-          `${report.name} offered a recipe and it could not be read (${quoteForeign(failedRead)}), so its version is missing rather than absent.`
+          `${report.name}'s search answered and offered a version, and that version could not be read (${quoteForeign(
+            `${failedRead.code}: ${failedRead.message}`
+          )}). The failure is in the reading, so nothing here says whether ${report.name} holds this dish.`
         );
       } else {
         notes.push(
@@ -2671,7 +2866,17 @@ ${shownDifferences.map((line) => `- ${line}`).join("\n")}${moreDifferences > 0 ?
         dish: args.dish,
         versions: payloads,
         differences,
-        per_source: merged.reports.map(toReportPayload),
+        // Two moments per source, told apart: whether the search answered, and
+        // what became of the row it offered.
+        per_source: merged.reports.map((report) => {
+          const payload = toReportPayload(report);
+          if (!opened.has(report.source)) return payload;
+          const failedRead = unread.get(report.source);
+          return withRead(
+            payload,
+            failedRead ? { status: "failed", error: { code: failedRead.code, message: failedRead.message } } : { status: "read", error: null }
+          );
+        }),
         notes
       },
       summary,
@@ -2883,6 +3088,13 @@ var searchRecipesOutput = z7.object({
   notes: z7.array(z7.string())
 });
 var WORDS_BEFORE_SAYING_SO = 4;
+function titleCarries(title, query) {
+  const fold = (text2) => text2.normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/œ/g, "oe").toLowerCase().replace(/[^a-z0-9]+/g, " ");
+  const haystack = ` ${fold(title)} `;
+  const words = fold(query).split(" ").filter((word) => word.length > 2);
+  if (words.length === 0) return true;
+  return words.some((word) => haystack.includes(` ${word}`));
+}
 async function runSearchRecipes(client, args) {
   try {
     const merged = await client.searchRecipes(
@@ -2900,6 +3112,11 @@ async function runSearchRecipes(client, args) {
         "This query went to each source as free text and no filter was applied to it. Words like 'vegan' or 'under 300 calories' help only where a source's own index happens to match them, so read the rows rather than assuming they meet every condition."
       );
     }
+    if (results.length > 0 && !results.some((row) => titleCarries(row.title, args.query))) {
+      notes.push(
+        `No title here carries a word of "${args.query}". These rows are what the sources ranked for that spelling, so read them as candidates to check rather than as recipes for the dish.`
+      );
+    }
     if (results.length === 0 && answered.length === merged.reports.length) {
       notes.push(
         "Every source answered and none holds anything under this wording. Try the dish's name in another language, or name a main ingredient instead."