mcp-recipes 1.2.0 → 1.3.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.2.0";
+var PKG_VERSION = "1.3.0";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -102,11 +102,17 @@ var RecipesError = class extends Error {
     this.details = details;
   }
 };
+var notFound = (message, details) => new RecipesError("not_found", message, details ?? {});
 var invalidInput = (message, hint) => new RecipesError("invalid_input", message, hint ? { hint } : {});
+var rateLimited = (message, details) => new RecipesError("rate_limited", message, {
+  hint: "Wait a moment and ask again. This says nothing about whether the recipe exists.",
+  ...details
+});
 var parseFailure = (message, details) => new RecipesError("parse_failure", message, {
   hint: `A site may have changed how it answers. Please report this at ${ISSUES_URL} with the arguments you used.`,
   ...details
 });
+var networkError = (message, details) => new RecipesError("network_error", message, details ?? {});
 var timeout = (message, details) => new RecipesError("timeout", message, details ?? {});
 function toRecipesError(error) {
   if (error instanceof RecipesError) return error;
@@ -117,6 +123,30 @@ function toRecipesError(error) {
   const details = raw && typeof raw.details === "object" && raw.details !== null ? raw.details : {};
   return new RecipesError(known ?? "network_error", message, details);
 }
+function fromSource(error, sourceName) {
+  if (error instanceof RecipesError) return error;
+  const known = toRecipesError(error);
+  const reported = known.message.replace(/\s+/g, " ").trim();
+  const opening = known.code === "not_found" ? `${sourceName} holds nothing under this name.` : `${sourceName} could not be read.`;
+  const message = reported === "" ? opening : `${opening} It reports: "${reported}"`;
+  const details = {};
+  if (known.details.url !== void 0) details.url = known.details.url;
+  if (known.details.status !== void 0) details.status = known.details.status;
+  switch (known.code) {
+    case "not_found":
+      return notFound(message, details);
+    case "invalid_input":
+      return invalidInput(message);
+    case "rate_limited":
+      return rateLimited(message, details);
+    case "parse_failure":
+      return parseFailure(message, details);
+    case "timeout":
+      return timeout(message, details);
+    default:
+      return networkError(message, details);
+  }
+}
 
 // src/sources/adapter.ts
 function text(value) {
@@ -349,6 +379,9 @@ function cookbookDetail(payload) {
     yieldUnit: text(recipe.yieldUnit) ?? span.unit,
     ingredients: textList(recipe.ingredients),
     steps: textList(recipe.steps),
+    // The page's own headings, which the reader reports. An answer holding no
+    // ingredient line uses them to say whether the page announced a list.
+    publishedSections: Array.isArray(recipe.sectionTitles) ? textList(recipe.sectionTitles) : null,
     // The Cookbook publishes one time for a recipe rather than splitting it.
     prepMinutes: null,
     cookMinutes: null,
@@ -466,6 +499,10 @@ function marmitonDetail(payload) {
     yieldUnit: span.unit ?? text(yields.unit),
     ingredients: textList(recipe.ingredients),
     steps: textList(recipe.steps),
+    // The reader hands over the parts of a page it recognised and not the
+    // headings the page carries, so there is nothing here to say how it is
+    // laid out.
+    publishedSections: null,
     prepMinutes: count(recipe.prepMinutes),
     cookMinutes: count(recipe.cookMinutes),
     totalMinutes: count(recipe.totalMinutes),
@@ -518,6 +555,473 @@ function selectSources(sources, wanted) {
   return chosen;
 }
 
+// src/sources/wordings.ts
+var MAX_WORDINGS_PER_SOURCE = 3;
+var FRENCH_FRAME = /* @__PURE__ */ new Set([
+  "a",
+  "ai",
+  "aimerais",
+  "au",
+  "aurais",
+  "auriez",
+  "aux",
+  "avec",
+  "avons",
+  "bcp",
+  "beaucoup",
+  "bien",
+  "bonjour",
+  "bonne",
+  "bonnes",
+  "cherche",
+  "chercher",
+  "cherchez",
+  "connais",
+  "connaissez",
+  "coucou",
+  "ce",
+  "ces",
+  "cette",
+  "comment",
+  "d",
+  "dans",
+  "de",
+  "des",
+  "du",
+  "en",
+  "est",
+  "et",
+  "facile",
+  "faire",
+  "fais",
+  "fait",
+  "idee",
+  "idees",
+  "id\xE9e",
+  "id\xE9es",
+  "j",
+  "je",
+  "l",
+  "la",
+  "le",
+  "les",
+  "ma",
+  "meilleur",
+  "meilleure",
+  "merci",
+  "mes",
+  "mon",
+  "ou",
+  "par",
+  "peux",
+  "plait",
+  "pla\xEEt",
+  "plus",
+  "pour",
+  "qu",
+  "que",
+  "quel",
+  "quelle",
+  "quelles",
+  "quels",
+  "qui",
+  "rapide",
+  "recette",
+  "recettes",
+  "recherche",
+  "s",
+  "salut",
+  "se",
+  "si",
+  "simple",
+  "sommes",
+  "souhaite",
+  "stp",
+  "suis",
+  "sur",
+  "svp",
+  "tres",
+  "tr\xE8s",
+  "un",
+  "une",
+  "veux",
+  "voudrais",
+  "vous",
+  "\xE0"
+]);
+var ENGLISH_FRAME = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "am",
+  "an",
+  "and",
+  "any",
+  "anything",
+  "are",
+  "at",
+  "be",
+  "best",
+  "by",
+  "can",
+  "could",
+  "do",
+  "does",
+  "easy",
+  "find",
+  "for",
+  "from",
+  "get",
+  "good",
+  "hello",
+  "hi",
+  "how",
+  "i",
+  "in",
+  "into",
+  "is",
+  "it",
+  "like",
+  "looking",
+  "make",
+  "making",
+  "me",
+  "my",
+  "need",
+  "of",
+  "on",
+  "or",
+  "please",
+  "quick",
+  "recipe",
+  "recipes",
+  "should",
+  "simple",
+  "some",
+  "something",
+  "suggest",
+  "thank",
+  "thanks",
+  "that",
+  "the",
+  "less",
+  "over",
+  "than",
+  "to",
+  "under",
+  "want",
+  "what",
+  "which",
+  "will",
+  "with",
+  "would",
+  "you",
+  "your"
+]);
+var CONDITION_UNITS = /* @__PURE__ */ new Set([
+  "calorie",
+  "calories",
+  "couvert",
+  "couverts",
+  "heure",
+  "heures",
+  "kcal",
+  "min",
+  "mins",
+  "minute",
+  "minutes",
+  "part",
+  "parts",
+  "people",
+  "person",
+  "persons",
+  "personne",
+  "personnes",
+  "portion",
+  "portions",
+  "serving",
+  "servings"
+]);
+var NEGATORS = /* @__PURE__ */ new Set([
+  "aucun",
+  "aucune",
+  "avoid",
+  "avoiding",
+  "eviter",
+  "evite",
+  "evitez",
+  "exclude",
+  "excluding",
+  "exclure",
+  "except",
+  "ni",
+  "no",
+  "non",
+  "not",
+  "pas",
+  "sans",
+  "sauf",
+  "without",
+  "zero"
+]);
+var HEALTH_MARKERS = /* @__PURE__ */ new Set([
+  "allergene",
+  "allergenes",
+  "allergen",
+  "allergens",
+  "allergic",
+  "allergie",
+  "allergies",
+  "allergique",
+  "allergiques",
+  "allergy",
+  "celiac",
+  "coeliaque",
+  "intolerance",
+  "intolerances",
+  "intolerant",
+  "intolerante",
+  "intolerantes",
+  "intolerants"
+]);
+var DIETS = /* @__PURE__ */ new Set([
+  "casher",
+  "cetogene",
+  "halal",
+  "kascher",
+  "keto",
+  "ketogenic",
+  "kosher",
+  "paleo",
+  "pescatarian",
+  "pescetarien",
+  "pescetarienne",
+  "vegan",
+  "vegane",
+  "veganes",
+  "vegans",
+  "vegetalien",
+  "vegetalienne",
+  "vegetaliennes",
+  "vegetaliens",
+  "vegetarian",
+  "vegetarians",
+  "vegetarien",
+  "vegetarienne",
+  "vegetariennes",
+  "vegetariens",
+  "veggie"
+]);
+var CONDITION_ENDS = /* @__PURE__ */ new Set([
+  "et",
+  "and",
+  "ou",
+  "or",
+  "pour",
+  "for",
+  "avec",
+  "with",
+  "mais",
+  "but",
+  "dans",
+  "sur"
+]);
+var CONDITION_JOINERS = /* @__PURE__ */ new Set([
+  "a",
+  "au",
+  "aux",
+  "d",
+  "de",
+  "des",
+  "du",
+  "from",
+  "l",
+  "la",
+  "le",
+  "les",
+  "my",
+  "of",
+  "the",
+  "to"
+]);
+var FOOD_LINKERS = /* @__PURE__ */ new Set(["d", "de", "des", "du", "of"]);
+var CONDITION_WORDS = 3;
+var SERVING_PHRASES = [
+  /\bpour\s+(\d{1,3})\s*(?:personnes?|parts?|couverts?)\b/iu,
+  /\bfor\s+(\d{1,3})\s*(?:people|persons?|servings?|portions?)\b/iu,
+  /\bserves?\s+(\d{1,3})\b/iu,
+  /\b(\d{1,3})\s*(?:personnes?|people|servings?)\b/iu
+];
+var FREE_OF = /\b([\p{L}]{3,})[\s-]?free\b/iu;
+function foldWord(word) {
+  return word.toLowerCase().normalize("NFD").replace(new RegExp("\\p{M}+", "gu"), "").replace(/œ/gu, "oe");
+}
+function readQuestion(question) {
+  const words = tokenise(question);
+  const conditions = [];
+  const dish = [];
+  const state = (named, kind) => {
+    const trimmed = named === null ? null : named.trim();
+    if (trimmed === "") return;
+    if (conditions.some((held) => held.named === trimmed && held.kind === kind)) return;
+    conditions.push({ named: trimmed, kind });
+  };
+  for (let index = 0; index < words.length; index += 1) {
+    const word = words[index];
+    const key = foldWord(word);
+    const hyphen = word.indexOf("-");
+    if (hyphen > 0 && NEGATORS.has(foldWord(word.slice(0, hyphen)))) {
+      state(word.slice(hyphen + 1), "excluded");
+      continue;
+    }
+    const free = FREE_OF.exec(word);
+    if (free) {
+      state(free[1], "excluded");
+      continue;
+    }
+    if (key === "free") {
+      const scope = scopeOf(words, index, dish);
+      if (scope.named !== null) {
+        state(scope.named, "excluded");
+        index = scope.next - 1;
+      }
+      continue;
+    }
+    if (NEGATORS.has(key)) {
+      const forward = takeFood(words, index + 1);
+      state(forward.named === "" ? null : forward.named, "excluded");
+      index = forward.next - 1;
+      continue;
+    }
+    if (HEALTH_MARKERS.has(key)) {
+      const scope = scopeOf(words, index, dish);
+      state(scope.named, "allergy");
+      index = scope.next - 1;
+      continue;
+    }
+    if (DIETS.has(key)) {
+      state(word, "diet");
+      continue;
+    }
+    if (FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key)) continue;
+    if (FRENCH_FRAME.has(word) || ENGLISH_FRAME.has(word)) continue;
+    if (/^\d+$/.test(word)) continue;
+    if (word.length < 2) continue;
+    if (CONDITION_UNITS.has(word)) continue;
+    if (!dish.includes(word)) dish.push(word);
+  }
+  return { dish, conditions };
+}
+function scopeOf(words, marker, dish) {
+  if (CONDITION_JOINERS.has(foldWord(words[marker + 1] ?? ""))) {
+    const forward = takeFood(words, marker + 1);
+    return { named: forward.named === "" ? null : forward.named, next: forward.next };
+  }
+  const before = words[marker - 1];
+  if (before !== void 0) {
+    const held = dish.lastIndexOf(before);
+    if (held !== -1) {
+      dish.splice(held, 1);
+      return { named: before, next: marker + 1 };
+    }
+  }
+  return { named: null, next: marker + 1 };
+}
+function takeFood(words, from) {
+  let index = from;
+  while (index < words.length && isFiller(words[index])) index += 1;
+  const named = [];
+  while (index < words.length && named.length < CONDITION_WORDS) {
+    if (!namesFood(words[index])) break;
+    named.push(words[index]);
+    index += 1;
+    const beyond = words[index + 1];
+    if (named.length + 2 <= CONDITION_WORDS && FOOD_LINKERS.has(foldWord(words[index] ?? "")) && beyond !== void 0 && namesFood(beyond)) {
+      named.push(words[index]);
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return { named: named.join(" "), next: index };
+}
+function isFiller(word) {
+  const key = foldWord(word);
+  return CONDITION_JOINERS.has(key) || FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key);
+}
+function namesFood(word) {
+  const key = foldWord(word);
+  if (key.length < 2) return false;
+  if (/^\d+$/.test(key)) return false;
+  if (key === "free") return false;
+  if (CONDITION_ENDS.has(key)) return false;
+  if (NEGATORS.has(key) || HEALTH_MARKERS.has(key)) return false;
+  if (CONDITION_UNITS.has(key)) return false;
+  return !(FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key));
+}
+function readConditions(question) {
+  const { conditions } = readQuestion(question);
+  let servings = null;
+  for (const phrase of SERVING_PHRASES) {
+    const found = phrase.exec(question);
+    if (found) {
+      const value = Number(found[1]);
+      if (Number.isFinite(value) && value > 0) {
+        servings = value;
+        break;
+      }
+    }
+  }
+  return { conditions, servings };
+}
+function deriveWordings(question) {
+  const asked = tidy(question);
+  const wordings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const offer = (candidate, derivation) => {
+    const clean = tidy(candidate);
+    if (clean === "") return;
+    const key = clean.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    wordings.push({ query: clean, derivation });
+  };
+  offer(asked, "the words as asked, condition words included");
+  const dish = dishWords(asked);
+  offer(
+    dish.join(" "),
+    "the words naming the dish, with the words framing the question and the conditions set aside, because a page is named for what it holds"
+  );
+  offer(
+    dish[0] ?? "",
+    "the leading dish word on its own, because an index that requires every word given returns nothing for a phrase and a great deal for the word naming the dish"
+  );
+  return wordings.slice(0, MAX_WORDINGS_PER_SOURCE);
+}
+function namesDish(title, question) {
+  const words = namingWords(question);
+  if (words.length === 0) return true;
+  return dishWordsMissing(title, question).length < words.length;
+}
+function dishWordsMissing(title, question) {
+  const haystack = ` ${fold(title)} `;
+  return namingWords(question).filter((word) => !haystack.includes(` ${fold(word)}`));
+}
+function namingWords(question) {
+  return dishWords(question).filter((word) => word.length > 2);
+}
+function fold(value) {
+  return value.normalize("NFD").replace(new RegExp("\\p{M}+", "gu"), "").replace(/œ/gu, "oe").toLowerCase().replace(/[^a-z0-9]+/g, " ");
+}
+function dishWords(question) {
+  return readQuestion(question).dish;
+}
+function tokenise(value) {
+  return value.toLowerCase().replace(/['’]/gu, " ").split(/[^\p{L}\p{N}-]+/u).map((word) => word.replace(/^-+|-+$/g, "")).filter((word) => word !== "");
+}
+function tidy(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
 // src/sources/client.ts
 var MAX_LIMIT_PER_SOURCE = 25;
 function withGuarantees(config) {
@@ -550,9 +1054,7 @@ function withDeadline(work, ms, source) {
   const alarm = new Promise((_resolve, reject) => {
     timer = setTimeout(
       () => reject(
-        timeout(
-          `${source.name} did not answer within ${ms}ms and was left out of this answer.`
-        )
+        timeout(`${source.name} did not answer within ${ms}ms and was left out of this answer.`)
       ),
       ms
     );
@@ -571,7 +1073,20 @@ function reportOf(attempt, count2) {
     skipped: attempt.skipped,
     mixesReferencePages: attempt.source.mixesReferencePages,
     cached: attempt.cached,
-    error: attempt.error
+    error: attempt.error,
+    wordings: attempt.wordings,
+    preferredByName: attempt.preferredByName
+  };
+}
+function heldBack(wording, because) {
+  return {
+    query: wording.query,
+    derivation: wording.derivation,
+    ran: false,
+    count: null,
+    added: null,
+    notRunBecause: because,
+    error: null
   };
 }
 function interleave(groups) {
@@ -631,15 +1146,22 @@ var RecipesClient = class {
    * source rather than as long as all of them. Whichever of them fail, the rest
    * still come back, and the report says which was which.
    */
-  async searchRecipes(query, limitPerSource, wanted) {
+  async searchRecipes(query, limitPerSource, wanted, options = {}) {
     const trimmed = query.trim();
     if (trimmed === "") {
       throw invalidInput("A search needs something to look for.", "Name a dish or an ingredient.");
     }
+    if (!/[\p{L}\p{N}]/u.test(trimmed)) {
+      throw invalidInput(
+        `"${trimmed}" carries no letter and no digit, so there is no word to search for.`,
+        "Name a dish or an ingredient."
+      );
+    }
     const chosen = selectSources(this.sources, wanted);
     const limit = Math.max(1, Math.min(MAX_LIMIT_PER_SOURCE, Math.trunc(limitPerSource)));
+    const fanOut = options.fanOut ?? true;
     const attempts = await Promise.all(
-      chosen.map((source) => this.searchOne(source, trimmed, limit))
+      chosen.map((source) => this.searchOne(source, trimmed, limit, fanOut))
     );
     const groups = attempts.map((attempt) => attempt.rows.slice(0, limit));
     return {
@@ -647,40 +1169,135 @@ var RecipesClient = class {
       reports: attempts.map((attempt, index) => reportOf(attempt, groups[index].length))
     };
   }
-  async searchOne(source, query, limit) {
-    try {
-      const read = await withDeadline(source.search(query, limit), this.deadlineMs, source);
-      if (read.skipped > 0) {
-        this.logger.warn(
-          `${source.name} sent ${read.skipped} row(s) this server could not read; they were left out.`
+  /**
+   * Ask one source the question in several wordings, and union what comes back.
+   *
+   * The wordings go out one after another rather than together, because each
+   * source is paced and a burst would spend the whole ladder's politeness at
+   * once. They stop early: a wording is only sent when the ones before it left
+   * the source short of what was asked for, so the ordinary case where the
+   * question names a dish costs one request.
+   *
+   * Each wording is a different search rather than a further page of the same
+   * one. One of these sites serves a single page of results and disallows
+   * paging past it, so a second page is never asked for, here or anywhere else.
+   */
+  async searchOne(source, question, limit, fanOut) {
+    const derived = deriveWordings(question);
+    const wordings = [];
+    const rows = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cached = false;
+    let skipped = 0;
+    let reportedTotal = null;
+    let reportedTotalMeans = null;
+    let answered = false;
+    let failure = null;
+    let onTopic = 0;
+    for (const [index, wording] of derived.entries()) {
+      if (index > 0 && !fanOut) {
+        wordings.push(
+          heldBack(wording, "fan_out was turned off, so only the words as asked were sent")
         );
+        continue;
       }
-      return {
-        source,
-        rows: read.rows,
-        cached: read.cached,
-        reportedTotal: read.reportedTotal,
-        reportedTotalMeans: read.reportedTotalMeans,
-        skipped: read.skipped,
-        error: null
-      };
-    } catch (error) {
-      const known = toRecipesError(error);
-      this.logger.warn(`${source.name} did not answer: [${known.code}] ${known.message}`);
-      return {
-        source,
-        rows: [],
-        cached: false,
-        reportedTotal: null,
-        reportedTotalMeans: null,
-        skipped: 0,
-        error: {
+      if (index >= MAX_WORDINGS_PER_SOURCE) {
+        wordings.push(
+          heldBack(
+            wording,
+            `the ceiling of ${MAX_WORDINGS_PER_SOURCE} searches of one source was reached`
+          )
+        );
+        continue;
+      }
+      if (failure !== null) {
+        wordings.push(
+          heldBack(wording, `${source.name} did not answer the wording before this one`)
+        );
+        continue;
+      }
+      if (onTopic >= limit) {
+        wordings.push(
+          heldBack(
+            wording,
+            "the wordings already sent returned as many rows naming the dish as were asked for"
+          )
+        );
+        continue;
+      }
+      try {
+        const read = await withDeadline(
+          source.search(wording.query, limit),
+          this.deadlineMs,
+          source
+        );
+        answered = true;
+        cached = cached || read.cached;
+        skipped += read.skipped;
+        if (reportedTotal === null && reportedTotalMeans === null) {
+          reportedTotal = read.reportedTotal;
+          reportedTotalMeans = read.reportedTotalMeans;
+        }
+        if (read.skipped > 0) {
+          this.logger.warn(
+            `${source.name} sent ${read.skipped} row(s) this server could not read; they were left out.`
+          );
+        }
+        let added = 0;
+        for (const row of read.rows) {
+          if (seen.has(row.id)) continue;
+          seen.add(row.id);
+          rows.push(row);
+          added += 1;
+          if (namesDish(row.title, question)) onTopic += 1;
+        }
+        wordings.push({
+          query: wording.query,
+          derivation: wording.derivation,
+          ran: true,
+          count: read.rows.length,
+          added,
+          notRunBecause: null,
+          error: null
+        });
+      } catch (error) {
+        const known = fromSource(error, source.name);
+        this.logger.warn(
+          `${source.name} did not answer "${wording.query}": [${known.code}] ${known.message}`
+        );
+        const reason = {
           code: known.code,
           message: known.message,
           ...known.details.hint ? { hint: known.details.hint } : {}
-        }
-      };
+        };
+        wordings.push({
+          query: wording.query,
+          derivation: wording.derivation,
+          ran: true,
+          count: null,
+          added: null,
+          notRunBecause: null,
+          error: reason
+        });
+        failure = reason;
+      }
     }
+    const contributing = wordings.filter((attempt) => (attempt.added ?? 0) > 0).length;
+    const ordered = contributing > 1 ? [
+      ...rows.filter((row) => namesDish(row.title, question)),
+      ...rows.filter((row) => !namesDish(row.title, question))
+    ] : rows;
+    return {
+      source,
+      rows: ordered,
+      preferredByName: contributing > 1,
+      cached,
+      reportedTotal,
+      reportedTotalMeans,
+      skipped,
+      error: answered ? null : failure,
+      wordings
+    };
   }
   /**
    * Read one recipe, from whichever source the identifier names.
@@ -699,7 +1316,7 @@ var RecipesClient = class {
       );
       return { recipe: outcome.recipe, cached: outcome.cached, read };
     } catch (error) {
-      throw toRecipesError(error);
+      throw fromSource(error, read.source.name);
     }
   }
 };
@@ -719,7 +1336,10 @@ var ENGLISH_FOODS = /\b(?:eggs?|salt|pepper|sugar|flour|butter|milk|cream|oil|ga
 var STRUCTURAL = 3;
 var VOCABULARY = 2;
 var NAME = 1;
-function readLanguage(line, evidence = { frenchUnit: false, englishUnit: false }) {
+function readLanguage(line, evidence = {
+  frenchUnit: false,
+  englishUnit: false
+}) {
   let french = 0;
   let english = 0;
   if (FRENCH_WORDS.test(line)) french += STRUCTURAL;
@@ -1042,8 +1662,10 @@ var EMBEDDED = {
 };
 function buildEmbedded(language) {
   const keys = UNIT_KEYS[language].map((key) => key.replace(/ /g, "\\s+"));
-  return new RegExp(`\\d[\\d.,/]*\\s*(?:${keys.join("|")})\\b`, "i");
+  const joiner = "(?:(?:de|du|des|d|of|a|an|the)\\s+)?";
+  return new RegExp(`\\d[\\d.,/]*\\s*${joiner}(?:${keys.join("|")})\\b`, "i");
 }
+var CONTAINER_NOUN = /^(?:cans?|tins?|jars?|packets?|packages?|packs?|box|boxes|bottles?|cartons?|bags?|tubs?|sachets?|blocks?|blocs?|boites?|pots?|briques?|bocaux|bocals?|barquettes?)\b/i;
 function hasEmbeddedMeasure(text2, language) {
   return EMBEDDED[language].test(normalizeUnitKey(text2));
 }
@@ -1188,15 +1810,24 @@ function chooseReadableUnit(unit, amount) {
     current = step.unit;
   }
   const up = PROMOTIONS[normalizeUnitKey(current.canonical)];
-  if (up && amount * ratio >= up.per) {
+  if (up && amount * ratio >= up.per && writesExactly(amount * ratio / up.per)) {
     const target = lookupUnit(up.to, up.language);
     if (target) {
       ratio /= up.per;
       current = target;
     }
   }
+  while (!writesExactly(amount * ratio)) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    ratio *= step.per;
+    current = step.unit;
+  }
   return { unit: current, ratio };
 }
+function writesExactly(value) {
+  return Math.abs(value * 100 - Math.round(value * 100)) < 1e-9;
+}
 function formatUnit(unit, amount, language) {
   if (unit.symbol) return unit.canonical;
   const singular = language === "fr" ? amount < 2 : amount <= 1;
@@ -1280,6 +1911,40 @@ function isStatedSize(text2) {
   if (!measure.unit || measure.unit.kind !== "measured") return false;
   return !CONTAINER_CONTENTS.test(measure.rest);
 }
+function takeCompoundMember(text2, unit, language) {
+  if (!unit) return null;
+  const step = demoteUnit(unit);
+  if (!step) return null;
+  const joiner = ADDS_UP.exec(text2);
+  if (joiner) text2 = text2.slice(joiner[0].length);
+  const second = parseLeadingQuantity(text2, language);
+  if (!second || second.amount <= 0 || second.amount >= step.per) return null;
+  const after = text2.slice(second.length);
+  const measure = takeUnit(after.trimStart(), language);
+  if (measure.unit) {
+    if (measure.unit.canonical !== step.unit.canonical) return null;
+    return { adds: second.amount / step.per, rest: measure.rest.trimStart() };
+  }
+  if (unit.kind !== "measured") return null;
+  if (!Number.isInteger(second.amount)) return null;
+  const trailing = after.trimStart();
+  if (trailing !== "" && !/^(?:de\s|d'|du\s|des\s|,)/i.test(trailing)) return null;
+  return { adds: second.amount / step.per, rest: trailing };
+}
+var ADDS_UP = /^\s*(?:\+|et|and|plus)\s+/i;
+var LEADING_DECORATION = /^(?:(?!~|≈|\()[^\p{L}\p{N}\s])+(?=\s)/u;
+function takeDecoration(text2) {
+  const match = LEADING_DECORATION.exec(text2);
+  return match ? match[0] : null;
+}
+function namesContainer(word) {
+  return word !== void 0 && CONTAINER_NOUN.test(normalizeUnitKey(word));
+}
+var TIME_UNIT = {
+  en: /^(?:h|hr|hrs|hours?|mins?|minutes?|secs?|seconds?|days?|nights?|weeks?)\b/i,
+  fr: /^(?:h|mn|heures?|mins?|minutes?|secs?|secondes?|jours?|nuits?|semaines?)\b/i
+};
+var ORDINAL_SUFFIX = /^(?:ers?|[eè]res?|[eè]mes?|es?|st|nd|rd|th)\b/i;
 var PER_PERSON = {
   en: /\bper\s+(?:person|head|serving|guest|diner)\b/i,
   fr: /\bpar\s+(?:personne|convive|part|t\u00eate)\b/i
@@ -1402,16 +2067,16 @@ function parseLeadingRange(text2, language) {
     length: low.length + separator[0].length + high.length
   };
 }
-var FRENCH_ARTICLES = { un: 1, une: 1, quelques: 3 };
+var FRENCH_ARTICLES = { un: 1, une: 1 };
 function takeUnit(text2, language) {
   const normalized = normalizeUnitKey(text2);
   for (const key of unitKeys(language)) {
     if (normalized !== key && !normalized.startsWith(`${key} `)) continue;
     const unit = lookupUnit(key, language);
     if (!unit) continue;
-    const wordCount = key.split(" ").length;
-    const words = text2.trim().split(/\s+/);
-    return { unit, rest: words.slice(wordCount).join(" ") };
+    const rest = afterKey(text2, key);
+    if (rest === null) continue;
+    return { unit, rest };
   }
   if (language === "en") {
     const words = text2.trimStart().split(/\s+/);
@@ -1420,6 +2085,14 @@ function takeUnit(text2, language) {
   }
   return { unit: null, rest: text2 };
 }
+function afterKey(text2, key) {
+  const words = text2.trim().split(/\s+/);
+  for (let count2 = 1; count2 <= words.length; count2 += 1) {
+    if (normalizeUnitKey(words.slice(0, count2).join(" ")) !== key) continue;
+    return words.slice(count2).join(" ");
+  }
+  return null;
+}
 function takeUnitEitherLanguage(text2, language) {
   const first = takeUnit(text2, language);
   if (first.unit) return first;
@@ -1435,13 +2108,16 @@ function readEvidence(line) {
 }
 function parseIngredient(line, choice = "auto") {
   const original = line;
-  const text2 = readable(line);
+  const marked = readable(line);
+  const decoration = takeDecoration(marked);
+  const text2 = decoration ? marked.slice(decoration.length).trimStart() : marked;
   const evidence = readEvidence(text2);
   const language = choice === "auto" ? evidence.language : choice;
-  const empty = (heldBack) => ({
+  const empty = (heldBack2) => ({
     original,
     language,
-    heldBack,
+    heldBack: heldBack2,
+    decoration,
     approximation: null,
     measureAdjective: null,
     amount: null,
@@ -1450,6 +2126,8 @@ function parseIngredient(line, choice = "auto") {
     unit: null,
     alternates: [],
     alternateStyle: null,
+    alternateIntro: null,
+    capacity: null,
     item: text2,
     articleWord: null,
     countMultiplier: null
@@ -1461,7 +2139,10 @@ function parseIngredient(line, choice = "auto") {
   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");
+  const behindFigure = stated.slice(quantity.length);
+  if (new RegExp("^-\\p{L}", "u").test(behindFigure)) return empty("sizeQualifier");
+  if (quantity !== article && ORDINAL_SUFFIX.test(behindFigure)) return empty(null);
+  if (TIME_UNIT[language].test(behindFigure.trimStart())) return empty("duration");
   let rest = stated.slice(quantity.length).trimStart();
   if (language === "en") rest = rest.replace(/^(?:of\s+)?an?\s+/i, "");
   const multiplier = readCountMultiplier(rest);
@@ -1473,26 +2154,44 @@ function parseIngredient(line, choice = "auto") {
   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 compound = range ? null : takeCompoundMember(rest, leading.unit, language);
+  if (compound) rest = compound.rest;
+  const whole = quantity.amount + (compound?.adds ?? 0);
+  const introducedBracket = /^(?:de\s+|du\s+|des\s+|d'|of\s+)(?=\()/i.exec(rest);
+  const bracketed = takeAlternates(
+    introducedBracket ? rest.slice(introducedBracket[0].length) : rest,
+    language
+  );
+  rest = bracketed.measures.length > 0 ? bracketed.rest : rest;
   const slashed = bracketed.measures.length > 0 ? null : takeSlashAlternates(rest, language);
   if (slashed) rest = slashed.rest;
-  const item = stripItemLead(rest, language);
+  let item = stripItemLead(rest, language);
+  const trailing = bracketed.measures.length === 0 && !slashed ? takeTrailingAlternates(item, language) : null;
+  if (trailing) item = trailing.item;
+  const group = trailing ?? (bracketed.measures.length > 0 ? bracketed : null);
+  const capacity = group !== null && group.measures.every((measure) => measure.unit?.kind === "measured") && (namesContainer(leading.unit?.canonical) || namesContainer(item)) ? group.published : null;
   if (language === "fr" && !leading.unit && statesItemSize(item)) return empty("itemSize");
   if (language === "fr" && leading.partitive && isStatedSize(item)) return empty("itemSize");
+  if (leading.unit?.kind === "measured" && CONTAINER_NOUN.test(normalizeUnitKey(item))) {
+    return empty("containerSize");
+  }
+  const alternates = capacity !== null ? [] : slashed?.measures ?? group?.measures ?? [];
   return {
     original,
     language,
     heldBack: PER_PERSON[language].test(text2) ? "perPerson" : null,
+    decoration,
     approximation: loose ? loose[0] : null,
     measureAdjective: behind?.unit ? described.adjective : null,
-    amount: quantity.amount * times,
+    amount: whole * times,
     amountMax: range === null ? null : range.max * times,
     rangeSeparator: range?.separator ?? null,
     unit: leading.unit,
-    alternates: slashed ? slashed.measures : bracketed.measures,
-    alternateStyle: slashed ? "slash" : bracketed.measures.length > 0 ? "bracket" : null,
-    item: stripItemLead(rest, language),
+    alternates,
+    alternateStyle: alternates.length === 0 ? null : slashed ? "slash" : trailing ? "trailing" : "bracket",
+    alternateIntro: capacity !== null ? null : group?.intro ?? null,
+    capacity,
+    item,
     articleWord: fromArticle ? article?.word ?? null : null,
     countMultiplier: multiplier?.times ?? null
   };
@@ -1508,7 +2207,7 @@ function unreadableComma(text2, language, evidence) {
 function readArticle(text2, language) {
   const counts = (rest) => takeLeadingUnit(rest, language, true).unit !== null || readCountMultiplier(rest) !== null;
   if (language === "fr") {
-    const match = /^\s*(un|une|quelques)\b\s*/i.exec(text2);
+    const match = /^\s*(un|une)\b\s*/i.exec(text2);
     if (!match) return null;
     if (!counts(text2.slice(match[0].length))) return null;
     const word = match[1];
@@ -1548,18 +2247,35 @@ function stripItemLead(text2, language) {
   return text2.replace(/^of\s+/i, "").replace(/^an?\s+/i, "").trim();
 }
 function takeAlternates(text2, language) {
-  if (!text2.startsWith("(")) return { measures: [], rest: text2 };
+  const none = { measures: [], intro: null, published: "", rest: text2 };
+  if (!text2.startsWith("(")) return none;
   const close = text2.indexOf(")");
-  if (close < 0) return { measures: [], rest: text2 };
-  const inside = text2.slice(1, close);
-  const parts = inside.split("/").map((part) => part.trim());
+  if (close < 0) return none;
+  const read = readBracket(text2.slice(0, close + 1), language);
+  if (!read) return none;
+  return { ...read, rest: text2.slice(close + 1).trimStart() };
+}
+var EQUIVALENT_INTRODUCER = /^(?:soit|environ|about|approx\.?|approximately|or|ou|=)\s*/i;
+var MEASURE_PARTITIVE = /^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+|of\s+)/i;
+function takeMeasureAfterQuantity(text2, language) {
+  const direct = takeUnitEitherLanguage(text2, language);
+  if (direct.unit) return direct;
+  const partitive = MEASURE_PARTITIVE.exec(text2);
+  if (!partitive) return direct;
+  return takeUnitEitherLanguage(text2.slice(partitive[0].length), language);
+}
+function readBracket(bracket, language) {
+  const inside = bracket.slice(1, -1);
+  const intro = EQUIVALENT_INTRODUCER.exec(inside);
+  const body = intro ? inside.slice(intro[0].length) : inside;
+  const parts = body.split(/(?<!\d)\/|\/(?!\d)/).map((part) => part.trim());
   const measures = [];
   for (const part of parts) {
     const range = parseLeadingRange(part, language);
     const quantity = range ?? parseLeadingQuantity(part, language);
-    if (!quantity) return { measures: [], rest: text2 };
-    const after = takeUnitEitherLanguage(part.slice(quantity.length).trimStart(), language);
-    if (!after.unit || after.rest.trim() !== "") return { measures: [], rest: text2 };
+    if (!quantity) return null;
+    const after = takeMeasureAfterQuantity(part.slice(quantity.length).trimStart(), language);
+    if (!after.unit || after.rest.trim() !== "") return null;
     measures.push({
       amount: quantity.amount,
       amountMax: range?.max ?? null,
@@ -1567,8 +2283,17 @@ function takeAlternates(text2, language) {
       unit: after.unit
     });
   }
-  if (measures.length === 0) return { measures: [], rest: text2 };
-  return { measures, rest: text2.slice(close + 1).trimStart() };
+  if (measures.length === 0) return null;
+  return { measures, intro: intro ? intro[0].trim() : null, published: bracket };
+}
+function takeTrailingAlternates(item, language) {
+  const closing = /\s*(\([^()]*\))\s*$/.exec(item);
+  if (!closing) return null;
+  const read = readBracket(closing[1], language);
+  if (!read) return null;
+  const head = item.slice(0, closing.index).trim();
+  if (head === "") return null;
+  return { ...read, item: head };
 }
 function takeSlashAlternates(text2, language) {
   const measures = [];
@@ -1619,6 +2344,7 @@ function roundTo(value, step) {
   return Math.round(Math.round(value / step) * step * 100) / 100;
 }
 function roundMeasured(value) {
+  if (Number.isInteger(value)) return value;
   if (value >= 100) return roundTo(value, 5);
   if (value >= 10) return roundTo(value, 1);
   if (value >= 1) return roundTo(value, 0.1);
@@ -1692,6 +2418,10 @@ function landedExactly(exact, amount) {
   if (gap > EXACT_WITHIN) return false;
   return exact === 0 || gap / Math.abs(exact) <= EXACT_SHARE;
 }
+function boundLandedExactly(bound) {
+  const fine = bound.ratio >= 1 ? bound.ratio : 1;
+  return landedExactly(bound.raw * fine, bound.amount * (fine / bound.ratio));
+}
 function scaleMeasure(low, high, unit, factor, divisibility) {
   const raws = high === null ? [low * factor] : [low * factor, high * factor];
   const sources = high === null ? [low] : [low, high];
@@ -1707,7 +2437,8 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
         amount: Math.min(usable, ceiling),
         exact,
         clamped: false,
-        raw
+        raw,
+        ratio
       };
     }),
     unit: target
@@ -1722,14 +2453,14 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
     const bounds2 = raws.map((raw, index) => {
       const ceiling = factor < 1 ? sources[index] : Number.POSITIVE_INFINITY;
       const rounded = roundSpoon(raw, ceiling);
-      return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw };
+      return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw, ratio: 1 };
     });
     return { bounds: bounds2, unit };
   }
   const bounds = raws.map((raw, index) => {
     const ceiling = factor < 1 ? sources[index] : Number.POSITIVE_INFINITY;
     const rounded = roundCountable(raw, divisibility, ceiling);
-    return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw };
+    return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw, ratio: 1 };
   });
   return { bounds, unit };
 }
@@ -1858,6 +2589,8 @@ var IRREGULAR_SINGULAR = Object.fromEntries(
   Object.entries(IRREGULAR_PLURAL).map(([one, many]) => [many, one])
 );
 function matchCase(source, replacement) {
+  const hasLetter = new RegExp("\\p{L}", "u").test(source);
+  if (hasLetter && source === source.toUpperCase()) return replacement.toUpperCase();
   if (source[0] === source[0]?.toUpperCase() && source.slice(1) === source.slice(1).toLowerCase()) {
     return replacement[0].toUpperCase() + replacement.slice(1);
   }
@@ -1906,6 +2639,15 @@ function agreeInEnglish(item, amount) {
   else return item;
   return `${words.join(" ")}${tail}`;
 }
+var FRENCH_OU_PLURAL_IN_X = /* @__PURE__ */ new Set([
+  "bijou",
+  "caillou",
+  "chou",
+  "genou",
+  "hibou",
+  "joujou",
+  "pou"
+]);
 var INVARIABLE_FRENCH_NOUN = /* @__PURE__ */ new Set([
   "ananas",
   "anis",
@@ -1966,14 +2708,14 @@ var AGREEABLE_ADJECTIVES = /* @__PURE__ */ new Set([
   "emince",
   "emincee"
 ]);
-function foldWord(word) {
+function foldWord2(word) {
   return word.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
 }
 function agreeTrailingAdjective(word, wantsPlural) {
-  const folded = foldWord(word);
+  const folded = foldWord2(word);
   const isPlural = folded.endsWith("s");
   const singular = isPlural ? word.slice(0, -1) : word;
-  if (!AGREEABLE_ADJECTIVES.has(foldWord(singular))) return null;
+  if (!AGREEABLE_ADJECTIVES.has(foldWord2(singular))) return null;
   if (wantsPlural === isPlural) return null;
   return wantsPlural ? `${word}s` : singular;
 }
@@ -1983,16 +2725,19 @@ function agreeInFrench(item, amount) {
   const head = words[0] ?? "";
   if (head.length <= 3) return item;
   const wantsPlural = amount >= 2;
-  const isPlural = /s$|eaux$|aux$/i.test(head);
+  const ouPlural = /x$/i.test(head) && FRENCH_OU_PLURAL_IN_X.has(foldWord2(head.slice(0, -1)));
+  const isPlural = /s$|eaux$|aux$/i.test(head) || ouPlural;
   if (wantsPlural && !isPlural) {
     if (/[sxz]$/i.test(head)) {
     } else if (/eau$/i.test(head)) words[0] = `${head}x`;
+    else if (FRENCH_OU_PLURAL_IN_X.has(foldWord2(head))) words[0] = `${head}x`;
     else if (/al$/i.test(head)) words[0] = `${head.slice(0, -2)}aux`;
     else words[0] = `${head}s`;
   } else if (!wantsPlural && isPlural) {
     if (/eaux$/i.test(head)) words[0] = head.slice(0, -1);
     else if (/aux$/i.test(head)) words[0] = `${head.slice(0, -3)}al`;
-    else if (INVARIABLE_FRENCH_NOUN.has(foldWord(head))) {
+    else if (ouPlural) words[0] = head.slice(0, -1);
+    else if (INVARIABLE_FRENCH_NOUN.has(foldWord2(head))) {
     } else words[0] = head.slice(0, -1);
   }
   const last = words.length - 1;
@@ -2005,16 +2750,22 @@ function agreeInFrench(item, amount) {
 function agreeLeadingAdjective(word, amount, language) {
   if (language === "en") return word;
   const wantsPlural = amount >= 2;
-  const folded = foldWord(word);
+  const folded = foldWord2(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 (!AGREEABLE_ADJECTIVES.has(foldWord2(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);
 }
+function agreeCountedContainer(item, amount, language) {
+  if (language === "fr") return agreeInFrench(item, amount);
+  const space = item.indexOf(" ");
+  if (space < 0) return agreeInEnglish(item, amount);
+  return `${agreeInEnglish(item.slice(0, space), amount)}${item.slice(space)}`;
+}
 var MUTE_H_WORDS = /^(?:huile|huiles|huitre|huitres|huître|huîtres|herbe|herbes|hysope)\b/i;
 function joinItem(item, language) {
   if (!item) return "";
@@ -2073,7 +2824,9 @@ function scaleAlternative(tail, options) {
 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.",
+  containerSize: "The measure here gives what one container holds rather than how many of them the recipe uses, and the line states no count, so it is left as published. Scaling it is a matter of opening that many containers of the size named.",
   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.",
+  duration: "This line states a length of time rather than an amount of an ingredient, so it is left as published. A rest, a proof or a bake takes as long for a large batch as for a small one, and the factor has nothing to say about it.",
   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) {
@@ -2097,10 +2850,12 @@ function scaleSingleLine(line, options) {
   const alternates = parsed.alternates.map((measure) => renderMeasure(measure, factor, language));
   const primaryBounds = primary.bounds;
   const alternateBounds = alternates.flatMap((entry) => entry.bounds);
-  const movedPrimary = primaryBounds.some((b) => !landedExactly(b.exact, b.amount));
-  const movedAlternate = alternateBounds.some((b) => !landedExactly(b.exact, b.amount));
+  const movedPrimary = primaryBounds.some((bound) => !boundLandedExactly(bound));
+  const movedAlternate = alternateBounds.some((bound) => !boundLandedExactly(bound));
   const clamped = [...primaryBounds, ...alternateBounds].find((bound) => bound.clamped) ?? null;
   const restated = parsed.alternateStyle === "slash";
+  const carriesMore = hasEmbeddedMeasure(parsed.item, language);
+  const leftover = carriesMore && parsed.unit?.kind === "measured";
   const low = primaryBounds[0];
   const high = primaryBounds[1] ?? null;
   const unit = primary.unit;
@@ -2116,13 +2871,17 @@ function scaleSingleLine(line, options) {
   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 introduced = parsed.alternateIntro ? `${parsed.alternateIntro} ` : "";
+  const bracketed = alternates.length === 0 ? "" : ` (${introduced}${alternateTexts.join(" / ")})`;
+  const altLabel = alternates.length === 0 ? "" : parsed.alternateStyle === "slash" ? ` / ${alternateTexts.join(" / ")}` : parsed.alternateStyle === "trailing" ? "" : bracketed;
+  const trailingLabel = parsed.alternateStyle === "trailing" ? bracketed : "";
+  const capacityLabel = parsed.capacity ? ` ${parsed.capacity}` : "";
+  const counted = parsed.capacity ? agreeCountedContainer(parsed.item, shown, language) : agreeWithAmount(parsed.item, shown, language);
   const itemLabel = named ? joinItem(parsed.item, language) : counted ? ` ${counted}` : "";
   const result = {
-    text: `${parsed.approximation ?? ""}${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
+    text: `${parsed.decoration ? `${parsed.decoration} ` : ""}${parsed.approximation ?? ""}${amountText}${unitLabel}${capacityLabel}${altLabel}${itemLabel}${trailingLabel}`.trim(),
     original: parsed.original,
-    scaling: movedPrimary || movedAlternate || restated ? "rounded" : "scaled",
+    scaling: movedPrimary || movedAlternate || restated || leftover ? "rounded" : "scaled",
     amount: low.amount,
     amountMax: collapsed ? null : high?.amount ?? null,
     unit: named?.canonical ?? null,
@@ -2135,7 +2894,7 @@ function scaleSingleLine(line, options) {
       `Clamped up to ${formatAmount(clamped.amount, language)} from ${formatAmount(Math.round(clamped.raw * 1e3) / 1e3, language)}, the smallest amount worth measuring. This line no longer holds its share of the recipe.`
     );
   } else if (movedPrimary) {
-    const moved = primaryBounds.filter((bound) => !landedExactly(bound.exact, bound.amount));
+    const moved = primaryBounds.filter((bound) => !boundLandedExactly(bound));
     sentences.push(
       moved.map(
         (bound) => `Rounded ${bound.amount > bound.exact ? "up" : "down"} from ${asPublished(bound.raw, parsed.unit)}.`
@@ -2150,11 +2909,16 @@ function scaleSingleLine(line, options) {
       "This line states one quantity twice, and both readings were scaled. They agree as closely as the page wrote them, and no closer."
     );
   }
-  if (hasEmbeddedMeasure(parsed.item, language)) {
+  if (carriesMore) {
     sentences.push(
       "This line carries a further quantity after the first one, and only the first was scaled. Read the rest as published."
     );
   }
+  if (parsed.capacity) {
+    sentences.push(
+      `${parsed.capacity} is what one container holds, so it stays as published and the count is what the factor moved. Scaling this line is a matter of opening that many containers of the size named.`
+    );
+  }
   if (collapsed) {
     sentences.push("The page gave a range, and at this size both ends come to the same amount.");
   }
@@ -2236,6 +3000,16 @@ function passthroughIngredients(lines, language = "auto") {
   return lines.map((line) => passthroughIngredient(line, language));
 }
 
+// src/recipe/sections.ts
+var HEADINGS = {
+  ingredients: /^\s*(?:ingr[ée]dients?|ingredients?|garniture)\b/i,
+  method: /^\s*(?:procedure|proc[ée]d[ée]|directions?|instructions?|method|preparation|pr[ée]paration|r[ée]alisation|steps?|[ée]tapes?)\b/i
+};
+function headingFor(part, headings) {
+  if (headings === null) return null;
+  return headings.find((heading) => HEADINGS[part].test(heading)) ?? null;
+}
+
 // src/tools/shared.ts
 import { z } from "zod";
 var MAX_TEXT_CHARS = 2200;
@@ -2259,6 +3033,22 @@ var reportSchema = z.object({
   ),
   skipped: z.number().int().describe("Rows this source sent in a shape the server could not read, and left out."),
   cached: z.boolean().describe("Served from this server's short-lived in-memory cache."),
+  preferred_by_name: z.boolean().describe(
+    "Whether this source's rows were arranged so the ones whose title names the dish come first. An order over one source's own rows, never a score against another source."
+  ),
+  wordings: z.array(
+    z.object({
+      query: z.string().describe("What was sent to this source, or would have been."),
+      derivation: z.string().describe("How this wording was derived from the question."),
+      ran: z.boolean(),
+      count: z.number().int().nullable().describe("Rows this wording returned. Null when it did not run."),
+      added: z.number().int().nullable().describe("Rows it returned that no earlier wording had."),
+      not_run_because: z.string().nullable().describe("Why it was held back. Null when it ran."),
+      error: z.object({ code: z.string(), message: z.string(), hint: z.string().optional() }).nullable()
+    })
+  ).describe(
+    "Every wording this source was sent or held back from, in the order tried. A question written as a sentence is also sent in wordings derived from it, because these indexes answer the words they are handed. Counts here belong to one wording each and are never added."
+  ),
   error: z.object({
     code: z.string(),
     message: z.string(),
@@ -2319,6 +3109,16 @@ function toReportPayload(report) {
     reported_total_means: report.reportedTotalMeans,
     skipped: report.skipped,
     cached: report.cached,
+    preferred_by_name: report.preferredByName,
+    wordings: report.wordings.map((attempt) => ({
+      query: attempt.query,
+      derivation: attempt.derivation,
+      ran: attempt.ran,
+      count: attempt.count,
+      added: attempt.added,
+      not_run_because: attempt.notRunBecause,
+      error: attempt.error
+    })),
     error: report.error ?? null,
     // A search alone opens nothing, so only a tool that reads a row fills this
     // in, through `withRead`.
@@ -2328,6 +3128,18 @@ function toReportPayload(report) {
 function withRead(payload, read) {
   return { ...payload, read };
 }
+function mustKeep(text2) {
+  return { text: text2, essential: true };
+}
+function noteText(note) {
+  return typeof note === "string" ? note : note.text;
+}
+function noteTexts(notes) {
+  return notes.map(noteText);
+}
+function labelNote(label, note) {
+  return typeof note === "string" ? `${label}: ${note}` : mustKeep(`${label}: ${note.text}`);
+}
 function reportNotes(reports) {
   const notes = [];
   const answered = reports.filter((report) => report.status === "answered");
@@ -2335,22 +3147,42 @@ function reportNotes(reports) {
   for (const report of failed) {
     const consolation = answered.length > 0 ? `This answer holds what the other sources found, and says nothing about what ${report.name} holds.` : "Nothing here is evidence about what it holds.";
     notes.push(
-      `${report.name} did not answer (${report.error?.code}): ${report.error?.message} ${consolation}`
+      mustKeep(
+        `${report.name} did not answer (${report.error?.code}): ${report.error?.message} ${consolation}`
+      )
     );
   }
   for (const report of answered) {
+    const sent = report.wordings.filter((attempt) => attempt.ran && attempt.error === null);
     if (report.count === 0) {
       notes.push(
-        `${report.name} answered and offered no row for this wording. That is a statement about the wording as much as about the corpus: try the dish's name in another language, or a main ingredient.`
+        mustKeep(
+          sent.length > 1 ? `${report.name} answered and offered no row for any of the ${sent.length} wordings it was sent (${sent.map((attempt) => `"${attempt.query}"`).join(", ")}). Each of those is a statement about a wording; together they are the closest this server comes to saying the corpus holds nothing. Try a main ingredient, or the dish's name in the language that source publishes in.` : `${report.name} answered and offered no row for this wording. That is a statement about the wording as much as about the corpus: try the dish's name in another language, or a main ingredient.`
+        )
+      );
+    }
+    if (sent.length > 1) {
+      notes.push(
+        `${report.name} was asked ${sent.length} wordings and these rows are their union: ${sent.map((attempt) => `"${attempt.query}" (${attempt.count ?? 0})`).join(", ")}. Those counts are per wording and are never added.`
+      );
+    }
+    if (report.preferredByName) {
+      notes.push(
+        `${report.name}'s rows are arranged with the ones naming the dish first, so a wording that returned near-misses cannot crowd out what another wording found. That is an order over one source's own rows and not a score against any other source.`
       );
     }
     if (report.skipped > 0) {
       notes.push(
-        `${report.name} sent ${report.skipped} row(s) in a shape this server could not read, and they were left out.`
+        mustKeep(
+          `${report.name} sent ${report.skipped} row(s) in a shape this server could not read, and they were left out.`
+        )
       );
     }
     if (report.reportedTotal !== null && report.reportedTotalMeans !== null) {
-      notes.push(`${report.name} reported ${report.reportedTotal}: ${report.reportedTotalMeans}.`);
+      const forWording = sent.length > 1 ? ` That number belongs to "${sent[0].query}" alone.` : "";
+      notes.push(
+        `${report.name} reported ${report.reportedTotal}: ${report.reportedTotalMeans}.${forWording}`
+      );
     } else {
       notes.push(
         `${report.name} states no total and offers no second page, so a short list here is not evidence that little exists.`
@@ -2360,7 +3192,7 @@ function reportNotes(reports) {
   if (answered.some((report) => report.mixesReferencePages && report.count > 0)) {
     const mixing = answered.filter((report) => report.mixesReferencePages && report.count > 0);
     notes.push(
-      `${mixing.map((report) => report.name).join(" and ")} files pages about an ingredient beside recipes using it, so a row here can be a page about an ingredient rather than a recipe. get_recipe says when a page carries no ingredient list.`
+      `${mixing.map((report) => report.name).join(" and ")} files pages about an ingredient beside recipes using it, so a row here can be a page about an ingredient rather than a recipe. get_recipe says what it read off the page.`
     );
   }
   if (answered.length > 1) {
@@ -2377,22 +3209,30 @@ var SERVER_MARKERS = /^(\s*)(Note|Sources?|Hint|Ingredients|Steps|What differs)(
 function quoteForeign(value) {
   return value.replace(/[\r\n\u2028\u2029\u0085]+/g, " ").replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").replace(/!\[/g, "!\\[").replace(/\s{2,}/g, " ").trim().replace(SERVER_MARKERS, " $1$2$3");
 }
-var LOAD_BEARING = /did not answer|could not be read|no longer holds its share|Published under|licen[cs]e|https?:\/\/|rather than a comparison|states no number of servings|no ingredient list|offered no row/i;
 var NOTE_BUDGET = Math.round(MAX_TEXT_CHARS * 0.55);
 function buildTrailer(options) {
-  const credit = options.credit ?? "Source: this server called none.";
-  const kept = [...new Set(options.notes ?? [])];
-  while (kept.length > 0 && kept.join("\n").length > NOTE_BUDGET) {
-    let victim = kept.length - 1;
+  const kept = [];
+  const held = /* @__PURE__ */ new Set();
+  for (const note of options.notes ?? []) {
+    const text2 = noteText(note);
+    if (held.has(text2)) continue;
+    held.add(text2);
+    kept.push(note);
+  }
+  const length = () => kept.map(noteText).join("\n").length;
+  while (kept.length > 0 && length() > NOTE_BUDGET) {
+    let victim = -1;
     for (let index = kept.length - 1; index >= 0; index -= 1) {
-      if (!LOAD_BEARING.test(kept[index])) {
+      if (typeof kept[index] === "string") {
         victim = index;
         break;
       }
     }
+    if (victim === -1) break;
     kept.splice(victim, 1);
   }
-  return [...kept.map((note) => `Note: ${note}`), credit].join("\n");
+  const credit = options.credit ?? "Source: this server called none.";
+  return [...kept.map((note) => `Note: ${noteText(note)}`), credit].join("\n");
 }
 function ok(structured, body, options = {}) {
   const trailer = buildTrailer(options);
@@ -2416,6 +3256,20 @@ function toToolError(error) {
 function roomForBody(options = {}) {
   return Math.max(200, MAX_TEXT_CHARS - buildTrailer(options).length - 60);
 }
+var ALWAYS_SHOWN = 3;
+function fitLines(lines, room) {
+  const kept = [];
+  let used = 0;
+  for (const line of lines) {
+    if (kept.length >= ALWAYS_SHOWN && used + line.length > room) break;
+    kept.push(line);
+    used += line.length + 1;
+  }
+  return { lines: kept, hidden: lines.length - kept.length };
+}
+function omittedLinesLine(shown, total, what) {
+  return `\u2026 ${shown} of ${total} ${what} shown here; all ${total} are in the structured output`;
+}
 function truncate(text2, maxChars) {
   if (text2.length <= maxChars) return text2;
   return `${text2.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
@@ -2497,7 +3351,9 @@ function resolveFactor(recipe, servings) {
     return {
       factor: null,
       notes: [
-        `${recipe.sourceName} states no number of servings for this recipe, so the quantities are as published. Use scale_ingredients with a factor you choose if you know what it serves.`
+        mustKeep(
+          `${recipe.sourceName} states no number of servings for this recipe, so the quantities are as published. Use scale_ingredients with a factor you choose if you know what it serves.`
+        )
       ]
     };
   }
@@ -2525,15 +3381,45 @@ function resolveFactor(recipe, servings) {
 function round(value) {
   return Math.round(value * 1e3) / 1e3;
 }
+var INGREDIENTS_PART = {
+  part: "ingredients",
+  entry: "ingredient line",
+  whole: "ingredient list",
+  caution: "An empty list here is never evidence that an ingredient is absent from the dish."
+};
+var METHOD_PART = {
+  part: "method",
+  entry: "step of method",
+  whole: "method",
+  caution: "An empty method here is never evidence that the dish is made without one."
+};
+function emptyPartNote(recipe, words) {
+  const heading = headingFor(words.part, recipe.publishedSections);
+  const counterpart = words.part === "ingredients" ? recipe.steps.length > 0 ? `${recipe.steps.length} step(s) of method were read from it` : null : recipe.ingredients.length > 0 ? `${recipe.ingredients.length} ingredient line(s) were read from it` : null;
+  const shown = [
+    heading === null ? null : `the page heads a section "${quoteForeign(heading)}"`,
+    counterpart
+  ].filter((clause) => clause !== null);
+  if (shown.length > 0) {
+    return mustKeep(
+      `No ${words.entry} was read from this page, yet ${shown.join(" and ")}. This server failed to read the ${words.whole} the page carries; read it at the url. ${words.caution}`
+    );
+  }
+  const looked = recipe.publishedSections === null ? "" : ", which heads no section announcing one";
+  return mustKeep(
+    `No ${words.entry} was read from this page${looked}. A page publishing no ${words.whole} and one written in a layout this server cannot follow look the same from here, so read the url before settling which this is. ${words.caution}`
+  );
+}
 function buildRecipeView(recipe, options) {
   const { factor, notes: yieldNotes } = resolveFactor(recipe, options.servings);
   const wants = (section) => options.sections.includes(section);
   const ingredients = factor === null || factor === 1 ? passthroughIngredients(recipe.ingredients, recipe.language) : scaleIngredients(recipe.ingredients, { factor, language: recipe.language });
   const notes = [...yieldNotes];
-  if (recipe.ingredients.length === 0) {
-    notes.push(
-      `${recipe.sourceName} publishes no ingredient list on this page. It is likely a page about the dish rather than a recipe for it, so there is nothing here to scale. Search again and pick another row.`
-    );
+  if (wants("ingredients") && recipe.ingredients.length === 0) {
+    notes.push(emptyPartNote(recipe, INGREDIENTS_PART));
+  }
+  if (wants("steps") && recipe.steps.length === 0) {
+    notes.push(emptyPartNote(recipe, METHOD_PART));
   }
   const rounded = ingredients.filter((entry) => entry.scaling === "rounded");
   const unscaled = ingredients.filter((entry) => entry.scaling === "unscaled");
@@ -2549,7 +3435,9 @@ function buildRecipeView(recipe, options) {
   }
   if (recipe.license) {
     notes.push(
-      `Published under ${quoteForeign(recipe.license.title)}: ${quoteForeign(recipe.license.url)}`
+      mustKeep(
+        `Published under ${quoteForeign(recipe.license.title)}: ${quoteForeign(recipe.license.url)}`
+      )
     );
   }
   const omitted = SECTIONS.filter((section) => !wants(section));
@@ -2604,7 +3492,7 @@ function buildRecipeView(recipe, options) {
   };
   if (options.label) {
     const label = quoteForeign(options.label);
-    return { payload, notes: notes.map((line) => `${label}: ${line}`), ingredients };
+    return { payload, notes: notes.map((line) => labelNote(label, line)), ingredients };
   }
   return { payload, notes, ingredients };
 }
@@ -2694,7 +3582,7 @@ function listNames(names2) {
   if (names2.length <= 1) return names2.join("");
   return `${names2.slice(0, -1).join(", ")} and ${names2[names2.length - 1]}`;
 }
-function describeDifferences(recipes, payloads) {
+function describeDifferences(recipes, payloads, sections) {
   if (recipes.length < 2) return [];
   const differences = [];
   const nameOf = (recipe) => recipe.sourceName;
@@ -2712,17 +3600,19 @@ function describeDifferences(recipes, payloads) {
       ).join("; ")}.`
     );
   }
-  const timed = recipes.filter((recipe) => recipe.totalMinutes !== null);
-  const untimed = recipes.filter((recipe) => recipe.totalMinutes === null);
-  if (timed.length > 0 && new Set(timed.map((recipe) => recipe.totalMinutes)).size > 1) {
-    differences.push(
-      `${timed.map((recipe) => `${nameOf(recipe)} states ${recipe.totalMinutes} minutes`).join("; ")}.`
-    );
-  }
-  if (timed.length > 0 && untimed.length > 0) {
-    differences.push(
-      `${listNames(untimed.map(nameOf))} states no time for this recipe, so there is nothing there to compare against.`
-    );
+  if (sections.includes("times")) {
+    const timed = recipes.filter((recipe) => recipe.totalMinutes !== null);
+    const untimed = recipes.filter((recipe) => recipe.totalMinutes === null);
+    if (timed.length > 0 && new Set(timed.map((recipe) => recipe.totalMinutes)).size > 1) {
+      differences.push(
+        `${timed.map((recipe) => `${nameOf(recipe)} states ${recipe.totalMinutes} minutes`).join("; ")}.`
+      );
+    }
+    if (timed.length > 0 && untimed.length > 0) {
+      differences.push(
+        `${listNames(untimed.map(nameOf))} states no time for this recipe, so there is nothing there to compare against.`
+      );
+    }
   }
   const rated = recipes.filter((recipe) => recipe.rating !== null);
   if (rated.length > 0 && rated.length < recipes.length) {
@@ -2801,28 +3691,63 @@ 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 (${quoteForeign(
-            `${report.error?.code ?? "unknown"}: ${report.error?.message ?? "unknown"}`
-          )}). Nothing here is evidence about what it holds.`
+          mustKeep(
+            `${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}'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.`
+          mustKeep(
+            `${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(
-          `${report.name} answered and offered nothing close enough to "${quoteForeign(args.dish)}" to compare.`
+          mustKeep(
+            `${report.name} answered and offered nothing close enough to "${quoteForeign(args.dish)}" to compare.`
+          )
         );
       }
     }
-    if (payloads.length === 1) {
+    const shortfall = payloads.map((payload) => dishWordsMissing(payload.title, args.dish));
+    const named = payloads.filter((_payload, index) => shortfall[index].length === 0);
+    const carriesDish = named.length > 0;
+    payloads.forEach((payload, index) => {
+      const missing = shortfall[index];
+      if (missing.length === 0) return;
+      notes.push(
+        mustKeep(
+          `${payload.source_name}'s closest row is ${quoteForeign(payload.title)}, whose title carries no ${missing.map((word) => `"${quoteForeign(word)}"`).join(" and no ")}. Read it as a candidate to check rather than as that dish.`
+        )
+      );
+    });
+    if (payloads.length > 0 && !carriesDish) {
+      notes.push(
+        `No version here carries the whole of "${quoteForeign(args.dish)}" in its title. These are the closest rows each source returned for that spelling, so read them as candidates to check rather than as that dish.`
+      );
+    }
+    if (payloads.length === 1 && carriesDish) {
       notes.push(
-        "This is one version rather than a comparison. Read it as what that one source publishes."
+        mustKeep(
+          "This is one version rather than a comparison. Read it as what that one source publishes."
+        )
+      );
+    }
+    const comparable = recipes.filter(
+      (recipe) => named.some((payload) => payload.id === recipe.id && payload.source === recipe.source)
+    );
+    const differences = comparable.length === payloads.length ? describeDifferences(recipes, payloads, args.sections) : [];
+    if (payloads.length > 1 && differences.length === 0 && comparable.length < payloads.length) {
+      notes.push(
+        mustKeep(
+          "Nothing is set side by side here: not every version's title carries the dish that was asked for, so what separates them may be that they are different dishes."
+        )
       );
     }
-    const differences = describeDifferences(recipes, payloads);
     if (payloads.length > 1) {
       notes.push(
         "Quantities are shown in the units each source published. Nothing was converted between measuring systems, so a gram in one version and a cup in another are two ways of writing a recipe rather than one quantity restated."
@@ -2843,20 +3768,20 @@ ${shownDifferences.map((line) => `- ${line}`).join("\n")}${moreDifferences > 0 ?
       const head = [
         `${quoteForeign(payload.source_name)}: ${quoteForeign(payload.title)}`,
         `  ${quoteForeign(payload.url)}`,
-        `  yields ${quoteForeign(payload.yield.original_text ?? "an unstated amount")}${payload.yield.factor === null ? "" : `, scaled by ${payload.yield.factor}`}`
+        // The yield is the page's, and the list under it is the one the factor
+        // produced. Stating the first alone above the second reads as a list
+        // for that many people.
+        `  ${renderYield(payload)}`
       ];
-      const lines = [...head];
-      let used = head.join("\n").length;
-      let shown = 0;
-      for (const entry of payload.ingredients.slice(0, TEXT_INGREDIENT_LINES)) {
-        const line = `  - ${quoteForeign(entry.text)}`;
-        if (used + line.length > share) break;
-        lines.push(line);
-        used += line.length + 1;
-        shown += 1;
+      const offered2 = payload.ingredients.slice(0, TEXT_INGREDIENT_LINES).map((entry) => `  - ${quoteForeign(entry.text)}`);
+      const fitted = fitLines(offered2, share - head.join("\n").length);
+      const lines = [...head, ...fitted.lines];
+      const hidden = payload.ingredients.length - fitted.lines.length;
+      if (hidden > 0) {
+        lines.push(
+          `  ${omittedLinesLine(fitted.lines.length, payload.ingredients.length, "ingredient lines")}`
+        );
       }
-      const hidden = payload.ingredients.length - shown;
-      if (hidden > 0) lines.push(`  \u2026 and ${hidden} more, in full in the structured output`);
       return lines.join("\n");
     });
     const body = payloads.length === 0 ? unread.size > 0 ? `Every version of "${quoteForeign(args.dish)}" that was offered could not be read, so nothing was compared.` : `No source offered a recipe for "${quoteForeign(args.dish)}".` : versionBlocks.join("\n\n");
@@ -2877,7 +3802,7 @@ ${shownDifferences.map((line) => `- ${line}`).join("\n")}${moreDifferences > 0 ?
             failedRead ? { status: "failed", error: { code: failedRead.code, message: failedRead.message } } : { status: "read", error: null }
           );
         }),
-        notes
+        notes: noteTexts(notes)
       },
       summary,
       { notes, credit }
@@ -2894,6 +3819,7 @@ var getRecipeDescription = [
   "'id' must come from search_recipes. It names the source, so this reads the right one without guessing; an identifier no source would have minted is refused, because sending it anywhere would answer about the wrong dish.",
   "Pass 'servings' to rescale. Quantities land where a kitchen can follow them: an egg stays whole, anything that pours or cuts can halve, a small measurement moves to a smaller unit before it is rounded, and anything unmultipliable is flagged rather than scaled.",
   "A page that states no number of servings comes back as published and says so, because dividing by a yield nobody wrote would answer for a number of people the page never claimed.",
+  "A part this answer holds nothing for says which of two things happened: the page showed no sign of it, or this server failed to read what the page carries. An empty ingredient list is never evidence that an ingredient is absent from the dish.",
   "'sections' decides what comes back, and 'sections_omitted' names what was left out: a field belonging to an omitted section is empty because nobody asked for it, never because the page states nothing.",
   "A field a source does not publish is null, never zero. Credit the source and link the url when you repeat any of it."
 ].join(" ");
@@ -2926,31 +3852,41 @@ async function runGetRecipe(client, args) {
     }
     if (cached) notes.push("Served from this server's short-lived in-memory cache.");
     const payload = view.payload;
-    const lines = [
+    const credit = creditLine([{ attribution: payload.attribution, url: payload.url }]);
+    const head = [
       `${quoteForeign(payload.title)} \xB7 ${quoteForeign(payload.source_name)}`,
       quoteForeign(payload.url),
       renderYield(payload)
     ];
-    if (payload.ingredients.length > 0) {
-      lines.push(
-        "",
-        "Ingredients:",
-        ...payload.ingredients.map(
-          (entry) => entry.scaling === "unscaled" ? `- ${quoteForeign(entry.text)} (no quantity)` : `- ${quoteForeign(entry.text)}`
-        )
-      );
+    const ingredientLines = payload.ingredients.map(
+      (entry) => entry.scaling === "unscaled" ? `- ${quoteForeign(entry.text)} (no quantity)` : `- ${quoteForeign(entry.text)}`
+    );
+    const stepLines = payload.steps.map((step, index) => `${index + 1}. ${quoteForeign(step)}`);
+    const room = roomForBody({ notes, credit }) - head.join("\n").length;
+    const parts = [ingredientLines, stepLines].filter((part) => part.length > 0);
+    const share = parts.length === 0 ? 0 : room / parts.length;
+    const lines = [...head];
+    const ingredients = fitLines(ingredientLines, share);
+    if (ingredientLines.length > 0) {
+      lines.push("", "Ingredients:", ...ingredients.lines);
+      if (ingredients.hidden > 0) {
+        lines.push(
+          omittedLinesLine(ingredients.lines.length, ingredientLines.length, "ingredient lines")
+        );
+      }
     }
-    if (payload.steps.length > 0) {
-      lines.push(
-        "",
-        "Steps:",
-        ...payload.steps.map((step, index) => `${index + 1}. ${quoteForeign(step)}`)
-      );
+    const steps = fitLines(stepLines, share);
+    if (stepLines.length > 0) {
+      lines.push("", "Steps:", ...steps.lines);
+      if (steps.hidden > 0) {
+        lines.push(omittedLinesLine(steps.lines.length, stepLines.length, "steps"));
+      }
     }
-    return ok({ recipe: payload, id_read_as: read.inferred, notes }, lines.join("\n"), {
-      notes,
-      credit: creditLine([{ attribution: payload.attribution, url: payload.url }])
-    });
+    return ok(
+      { recipe: payload, id_read_as: read.inferred, notes: noteTexts(notes) },
+      lines.join("\n"),
+      { notes, credit }
+    );
   } catch (error) {
     return toToolError(error);
   }
@@ -3008,6 +3944,10 @@ function resolveFactor2(args) {
     "Give 'factor', or both 'from_servings' and 'to_servings'."
   );
 }
+function statedFactor(factor) {
+  const shortened = Math.round(factor * 1e3) / 1e3;
+  return shortened === 0 ? Number(factor.toPrecision(3)) : shortened;
+}
 function runScaleIngredients(args) {
   try {
     const factor = resolveFactor2(args);
@@ -3047,13 +3987,13 @@ function runScaleIngredients(args) {
     const body = scaled.map((entry, index) => `${index + 1}. ${quoteForeign(entry.text)}`).join("\n");
     return ok(
       {
-        factor: Math.round(factor * 1e3) / 1e3,
+        factor: statedFactor(factor),
         language: args.language,
         ingredients: scaled.map(toIngredientPayload),
         ...counts,
         notes
       },
-      `Scaled by ${Math.round(factor * 1e3) / 1e3}:
+      `Scaled by ${statedFactor(factor)}:
 ${body}`,
       { notes, credit: "Source: the list you supplied. Scaled offline; nothing was fetched." }
     );
@@ -3068,8 +4008,11 @@ var searchRecipesDescription = [
   "Search every recipe source this server reads, at the same time, for a dish or an ingredient, and get one merged list.",
   "Each row carries the id get_recipe takes, and that id names the source it came from, so nothing has to be guessed afterwards.",
   "The sources are written in different languages and count their own results differently, so 'per_source' says what each one answered, what its own number means, and names any that failed. A short list is never evidence of what exists.",
-  "Some sources keep recipes and reference pages together, so a row can be a page about an ingredient rather than a recipe using it. Only get_recipe can tell them apart, and it says when a page carries no ingredient list.",
+  "Some sources keep recipes and reference pages together, so a row can be a page about an ingredient rather than a recipe using it. Only get_recipe can tell them apart, and it says what it read off the page.",
   "The query goes to each source's own search as free text. There is no filtering: a word naming a diet, a time or a calorie count matches only where that source's index happens to carry it.",
+  "Ask in a whole sentence if that is the question. These indexes answer the words they are handed, so a sentence is also sent as the words naming the dish and as the dish word alone, and the rows are the union; 'per_source' lists every wording and what it returned.",
+  "What the question says the recipe must not hold is set aside from those shorter wordings rather than searched for, and named back in the notes: a negation, an allergy stated as one, a diet named in one word, and the number of people at the table. No source filters on any of it, so open a row with get_recipe and read the ingredient list before calling it suitable.",
+  "A condition is read with the food on whichever side of it the sentence put one, so 'allergique aux noix' and 'peanut allergy' both name the nut. Where a sentence puts a food on neither side, the notes say a condition was stated and that its food was not read, because naming the wrong word would hide a dish and search for the food being avoided at once.",
   "Rows are interleaved one source at a time rather than ranked, because the sources share no score that could order them against each other."
 ].join(" ");
 var searchRecipesInput = strictInput({
@@ -3077,6 +4020,9 @@ var searchRecipesInput = strictInput({
   limit_per_source: z7.number().int().min(1).max(25).default(5).describe("Rows to take from each source, so one source cannot fill the whole list."),
   sources: z7.array(z7.string()).optional().describe(
     "Sources to ask, by id. Left out, they are all asked, which is the point of this tool. The ids are the ones 'per_source' reports."
+  ),
+  fan_out: z7.boolean().default(true).describe(
+    "Whether a question may also be sent in shorter wordings derived from it. On, because these indexes answer the words they are handed: a question written as a sentence comes back empty from a corpus holding several of the dish. Turn it off to send exactly the words typed; 'per_source' then names the wordings that were withheld."
   )
 });
 var searchRecipesOutput = z7.object({
@@ -3088,31 +4034,77 @@ 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(
       args.query,
       args.limit_per_source,
-      args.sources
+      args.sources,
+      { fanOut: args.fan_out }
     );
     const results = merged.rows.map(toRowPayload);
     const notes = reportNotes(merged.reports);
     const answered = merged.reports.filter((report) => report.status === "answered");
     const contributed = merged.reports.filter((report) => report.count > 0);
     const order = contributed.length > 1 ? "One row from each source in turn, in the order each source returned them. No score orders them against each other." : contributed.length === 1 ? `Every row came from ${contributed[0].name}, in the order it returned them.` : "No source contributed a row.";
+    const conditions = readConditions(args.query);
+    const named = (kind) => conditions.conditions.filter((condition) => condition.kind === kind && condition.named !== null).map((condition) => `"${quoteForeign(condition.named)}"`).join(" and ");
+    const unread = (kind) => conditions.conditions.some(
+      (condition) => condition.kind === kind && condition.named === null
+    );
+    const allergies = named("allergy");
+    if (allergies !== "") {
+      notes.push(
+        mustKeep(
+          `This question states an allergy to ${allergies}. No source filtered on it, and none can: these are searches over what a page holds rather than over what it leaves out, so a row here may be a recipe built on that ingredient. Open every row with get_recipe and read the whole ingredient list before cooking from it.`
+        )
+      );
+    }
+    if (unread("allergy")) {
+      notes.push(
+        mustKeep(
+          "This question states an allergy, and the words around it do not say plainly which food it names, so no food was read from it and none is named here. Nothing was set aside and no source filters on an allergy in any case: open every row with get_recipe and read the whole ingredient list before cooking from it."
+        )
+      );
+    }
+    const excluded = named("excluded");
+    if (excluded !== "") {
+      notes.push(
+        mustKeep(
+          `This question asks for a recipe free of ${excluded}. No source filtered on that, and none can: these are searches over what a page holds rather than over what it leaves out. Open a row with get_recipe and check the ingredient list before calling it suitable.`
+        )
+      );
+    }
+    if (unread("excluded")) {
+      notes.push(
+        mustKeep(
+          "This question says the recipe must leave something out, and the words around it do not say plainly which food it names, so nothing was read from it and nothing is named here. Open a row with get_recipe and read the ingredient list before calling it suitable."
+        )
+      );
+    }
+    const diets = named("diet");
+    if (diets !== "") {
+      notes.push(
+        mustKeep(
+          `This question names a diet: ${diets}. A diet is a rule about what a recipe leaves out, and no source filters on one, so the word was sent as text and matches only where a source's index happens to carry it. Open a row with get_recipe and read the ingredient list before calling it suitable.`
+        )
+      );
+    }
+    if (conditions.servings !== null) {
+      notes.push(
+        mustKeep(
+          `This question asks for ${conditions.servings} servings. That is not something a search matches, so it was not looked for. Pass 'servings' to get_recipe or compare_recipes to rescale a recipe once one is chosen.`
+        )
+      );
+    }
     if (args.query.trim().split(/\s+/).length > WORDS_BEFORE_SAYING_SO) {
       notes.push(
-        "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."
+        mustKeep(
+          "This query went to each source as free text and no filter was applied to it. Anything the question said the recipe must not contain went out as words like the rest of it, so read the rows rather than assuming they meet it."
+        )
       );
     }
-    if (results.length > 0 && !results.some((row) => titleCarries(row.title, args.query))) {
+    if (results.length > 0 && !results.some((row) => namesDish(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.`
       );
@@ -3122,8 +4114,17 @@ async function runSearchRecipes(client, args) {
         "Every source answered and none holds anything under this wording. Try the dish's name in another language, or name a main ingredient instead."
       );
     }
+    const derived = [
+      ...new Set(
+        merged.reports.flatMap(
+          (report) => report.wordings.filter((attempt) => attempt.ran && attempt.query !== args.query.trim()).map((attempt) => attempt.query)
+        )
+      )
+    ];
+    const alsoSent = derived.length > 0 ? `
+Also searched for: ${derived.map((wording) => `"${quoteForeign(wording)}"`).join(", ")}.` : "";
     const body = results.length > 0 ? `${results.length} recipes for "${args.query}":
-${renderRows(results)}` : answered.length === 0 ? `No source answered for "${args.query}", so nothing here says whether such a recipe exists.` : `Nothing came back for "${args.query}".`;
+${renderRows(results)}${alsoSent}` : answered.length === 0 ? `No source answered for "${args.query}", so nothing here says whether such a recipe exists.` : `Nothing came back for "${args.query}".${alsoSent}`;
     return ok(
       {
         query: args.query,
@@ -3131,7 +4132,7 @@ ${renderRows(results)}` : answered.length === 0 ? `No source answered for "${arg
         result_count: results.length,
         per_source: merged.reports.map(toReportPayload),
         order,
-        notes
+        notes: noteTexts(notes)
       },
       body,
       {