mcp-recipes 3.0.0 → 4.0.0

package/dist/index.js

@@ -11,7 +11,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import process from "process";
 
 // src/version.ts
-var PKG_VERSION = "3.0.0";
+var PKG_VERSION = "4.0.0";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -94,6 +94,7 @@ function loadConfig(env = process.env) {
 // src/sources/registry.ts
 import { GoodFoodClient } from "mcp-bbc-goodfood/client";
 import { MarmitonClient } from "mcp-marmiton/client";
+import { PequerecetasClient } from "mcp-pequerecetas/client";
 import { PtitchefClient } from "mcp-ptitchef/client";
 import { SupertoinetteClient } from "mcp-supertoinette/client";
 import { CookbookClient } from "mcp-wikibooks-cookbook/client";
@@ -254,8 +255,7 @@ var COOKBOOK_PROFILE = {
   homeUrl: "https://en.wikibooks.org/wiki/Cookbook:Table_of_Contents",
   language: "en",
   attribution: "Source: Wikibooks Cookbook",
-  // The namespace holds pages about salt and about a dish made with it alike.
-  mixesReferencePages: true
+  rowsThatAreNotRecipes: "a page about an ingredient"
 };
 var SITE_URL = /^https?:\/\/en\.wikibooks\.org\/wiki\//i;
 var NAMESPACE = /^cookbook\s*:/i;
@@ -362,6 +362,7 @@ function cookbookDetail(payload) {
     prepMinutes: null,
     cookMinutes: null,
     totalMinutes: count(recipe.totalMinutes),
+    gathers: null,
     category: text(recipe.category),
     // The page is written by everyone who edited it, so it credits nobody in
     // particular and carries no reader rating.
@@ -388,9 +389,7 @@ var GOODFOOD_PROFILE = {
   homeUrl: "https://www.bbcgoodfood.com",
   language: "en",
   attribution: "Source: BBC Good Food",
-  // The search serves recipe pages; a question aimed at the site's reviews and
-  // buying guides is answered with recipes all the same.
-  mixesReferencePages: false
+  rowsThatAreNotRecipes: null
 };
 var SITE_URL2 = /^https?:\/\/(?:www\.)?bbcgoodfood\.com\//i;
 var REFERENCE = /^recipes\/[^/]+$/;
@@ -529,6 +528,7 @@ function goodfoodDetail(payload) {
     } : null,
     // The site files a recipe under collections rather than under one category
     // on the page itself.
+    gathers: null,
     category: null,
     author: text(recipe.author),
     rating: value === null ? null : { value, count: count(recipe.rating_count), max: 5 },
@@ -548,8 +548,7 @@ var MARMITON_PROFILE = {
   homeUrl: "https://www.marmiton.org",
   language: "fr",
   attribution: "Source: Marmiton",
-  // Every page the search returns is a recipe.
-  mixesReferencePages: false
+  rowsThatAreNotRecipes: null
 };
 var SITE_URL3 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
 var REFERENCE2 = /^\d+$/;
@@ -649,6 +648,7 @@ function marmitonDetail(payload) {
     prepMinutes: count(recipe.prepMinutes),
     cookMinutes: count(recipe.cookMinutes),
     totalMinutes: count(recipe.totalMinutes),
+    gathers: null,
     category: text(recipe.category),
     author: text(recipe.author),
     rating: value === null ? null : { value, count: count(rating?.count), max: count(rating?.best) },
@@ -665,6 +665,181 @@ function marmitonDetail(payload) {
   };
 }
 
+// src/sources/pequerecetas.ts
+var PEQUERECETAS_PROFILE = {
+  id: "pequerecetas",
+  name: "Pequerecetas",
+  homeUrl: "https://www.pequerecetas.com",
+  language: "es",
+  attribution: "Source: Pequerecetas",
+  rowsThatAreNotRecipes: "an article gathering other recipes"
+};
+var SITE_RECIPE_URL = /^https?:\/\/(?:www\.)?pequerecetas\.com\/receta\/([a-z0-9]+(?:-[a-z0-9]+)*)\/?$/i;
+var REFERENCE3 = /^[a-z0-9]+(?:-[a-z0-9]+)+$/;
+function pequerecetasAdapter(reader) {
+  return {
+    ...PEQUERECETAS_PROFILE,
+    claims(raw) {
+      const address = SITE_RECIPE_URL.exec(raw);
+      if (address?.[1]) {
+        return {
+          reference: address[1],
+          why: "the address is a Pequerecetas recipe page",
+          guess: false
+        };
+      }
+      if (REFERENCE3.test(raw)) {
+        return {
+          reference: raw,
+          why: "hyphenated lowercase words are the shape Pequerecetas mints",
+          guess: true
+        };
+      }
+      return null;
+    },
+    async search(query) {
+      const outcome = await reader.searchRecipes(query);
+      const listing = outcome.data ?? {};
+      const list = rowsOf(listing.rows, PEQUERECETAS_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const row = toRow(summary);
+        if (row === null) {
+          skipped += 1;
+          continue;
+        }
+        rows.push(row);
+      }
+      return {
+        rows,
+        skipped,
+        // The site prints no count of what a search matched, and the rows of
+        // one page are not put here in its place.
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: pequerecetasDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function toRow(summary) {
+  const id = text(summary?.id);
+  const title = text(summary?.title);
+  const url = text(summary?.url);
+  if (!(id && title && url)) {
+    return null;
+  }
+  return {
+    id: namespacedId(PEQUERECETAS_PROFILE.id, id),
+    source: PEQUERECETAS_PROFILE.id,
+    sourceName: PEQUERECETAS_PROFILE.name,
+    title,
+    url,
+    imageUrl: text(summary?.image_url),
+    // A listing row carries no gloss on this site.
+    excerpt: null
+  };
+}
+function pequerecetasDetail(payload) {
+  const page = payload ?? {};
+  if (page.kind === "collection") {
+    return collectionDetail(page.collection);
+  }
+  return recipeDetail(page.recipe);
+}
+function recipeDetail(payload) {
+  const recipe = payload ?? {};
+  const rating = recipe.rating;
+  const value = count(rating?.value);
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const steps = Array.isArray(recipe.steps) ? recipe.steps : [];
+  const energy = recipe.nutrition;
+  const figure = text(energy?.text);
+  return {
+    ...detailBase(PEQUERECETAS_PROFILE),
+    id: namespacedId(PEQUERECETAS_PROFILE.id, required(recipe.id, "id", PEQUERECETAS_PROFILE)),
+    title: required(recipe.title, "title", PEQUERECETAS_PROFILE),
+    url: required(recipe.url, "url", PEQUERECETAS_PROFILE),
+    imageUrl: text(recipe.images?.[0]),
+    yieldCount: span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit,
+    // Carried as published, equipment among them: the site writes what a
+    // recipe is cooked with in this list, and telling the two apart is the
+    // scaler's work rather than this adapter's.
+    ingredients: textList(recipe.ingredients),
+    steps: steps.map((step) => text(step?.text)).filter((step) => step !== null),
+    // The headings the site groups its steps under belong to the method rather
+    // than to the page's layout, so no list of published sections is claimed.
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    restMinutes: null,
+    // The reader hands over the steps it read and says nothing about whether
+    // the page numbered them.
+    stepsAsOneBlock: null,
+    withheld: null,
+    gathers: null,
+    category: text(recipe.categories?.[0]),
+    author: text(recipe.author),
+    // The scale is published, so a value is never read against a guess.
+    rating: value === null ? null : { value, count: count(rating?.count), max: count(rating?.scale) },
+    // One figure, repeated in the words the page printed it with. The site
+    // states no serving size, so nothing is divided: an amount per serving
+    // would be arithmetic the page never showed.
+    nutrition: figure === null ? null : { calories: figure },
+    // The site keeps no list of its own: what a recipe is cooked with is
+    // written among the ingredients.
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+function collectionDetail(payload) {
+  const collection = payload ?? {};
+  const listed = Array.isArray(collection.recipes) ? collection.recipes : [];
+  return {
+    ...detailBase(PEQUERECETAS_PROFILE),
+    id: namespacedId(PEQUERECETAS_PROFILE.id, required(collection.id, "id", PEQUERECETAS_PROFILE)),
+    title: required(collection.title, "title", PEQUERECETAS_PROFILE),
+    url: required(collection.url, "url", PEQUERECETAS_PROFILE),
+    imageUrl: text(collection.images?.[0]),
+    yieldCount: null,
+    yieldMax: null,
+    yieldText: null,
+    yieldUnit: null,
+    ingredients: [],
+    steps: [],
+    publishedSections: null,
+    prepMinutes: null,
+    cookMinutes: null,
+    totalMinutes: null,
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    withheld: null,
+    gathers: {
+      headings: textList(collection.headings),
+      rows: listed.map(toRow).filter((row) => row !== null)
+    },
+    category: null,
+    author: null,
+    rating: null,
+    nutrition: null,
+    equipment: [],
+    tips: [],
+    license: null
+  };
+}
+
 // src/sources/ptitchef.ts
 var PTITCHEF_PROFILE = {
   id: "ptitchef",
@@ -672,18 +847,15 @@ var PTITCHEF_PROFILE = {
   homeUrl: "https://www.ptitchef.com",
   language: "fr",
   attribution: "Source: Ptitchef",
-  // Every row a listing serves names a recipe; a topic the site answers with a
-  // guide of its own groups recipes under headings rather than mixing in pages
-  // about ingredients.
-  mixesReferencePages: false
+  rowsThatAreNotRecipes: null
 };
 var SITE_URL4 = /^https?:\/\/(?:www\.)?ptitchef\.com\//i;
-var REFERENCE3 = /^recettes\/[^/]+\/[^/]+-fid-\d+$/;
+var REFERENCE4 = /^recettes\/[^/]+\/[^/]+-fid-\d+$/;
 var DOT_SEGMENT2 = /(?:^|\/)\.\.?(?:\/|$)/;
 var LEADING_SLASH2 = /^\/+/;
 function asReference2(raw) {
   const path = raw.replace(LEADING_SLASH2, "");
-  return REFERENCE3.test(path) && !DOT_SEGMENT2.test(`/${path}`) ? path : null;
+  return REFERENCE4.test(path) && !DOT_SEGMENT2.test(`/${path}`) ? path : null;
 }
 function meansFor2(listing) {
   if (count(listing.total_available) === null) {
@@ -784,6 +956,7 @@ function ptitchefDetail(payload) {
     restMinutes: null,
     stepsAsOneBlock: typeof recipe.steps_are_one_block === "boolean" ? recipe.steps_are_one_block : null,
     withheld: null,
+    gathers: null,
     category: text(recipe.category),
     author: text(recipe.author),
     // The site prints two counts beside a rating, one of readers who rated and
@@ -805,17 +978,15 @@ var SUPERTOINETTE_PROFILE = {
   homeUrl: "https://www.supertoinette.com",
   language: "fr",
   attribution: "Source: Supertoinette",
-  // The reader sets aside any row that opens onto something other than a
-  // recipe, so what arrives here is recipes.
-  mixesReferencePages: false
+  rowsThatAreNotRecipes: null
 };
-var SITE_RECIPE_URL = /^https?:\/\/(?:www\.)?supertoinette\.com\/recette\/([1-9][0-9]{0,9})\//i;
-var REFERENCE4 = /^[1-9][0-9]{0,9}$/;
+var SITE_RECIPE_URL2 = /^https?:\/\/(?:www\.)?supertoinette\.com\/recette\/([1-9][0-9]{0,9})\//i;
+var REFERENCE5 = /^[1-9][0-9]{0,9}$/;
 function supertoinetteAdapter(reader) {
   return {
     ...SUPERTOINETTE_PROFILE,
     claims(raw) {
-      const address = SITE_RECIPE_URL.exec(raw);
+      const address = SITE_RECIPE_URL2.exec(raw);
       if (address?.[1]) {
         return {
           reference: address[1],
@@ -823,7 +994,7 @@ function supertoinetteAdapter(reader) {
           guess: false
         };
       }
-      if (REFERENCE4.test(raw)) {
+      if (REFERENCE5.test(raw)) {
         return {
           reference: raw,
           why: "a bare number is the shape Supertoinette mints",
@@ -908,6 +1079,7 @@ function supertoinetteDetail(payload) {
     // the page numbered them.
     stepsAsOneBlock: null,
     withheld: null,
+    gathers: null,
     category: text(recipe.category),
     author: text(recipe.author),
     // The scale is published, so a value is never read against a guess.
@@ -925,30 +1097,54 @@ function supertoinetteDetail(payload) {
 
 // src/sources/registry.ts
 var PAGE_READ_BOUNDS = { maxBodyBytes: 8e6, budgetMs: 6e4 };
-function buildSources(config, readers, logger) {
-  const shared = {
+var PACING_FLOOR_MS = {
+  marmiton: 500,
+  cookbook: 500,
+  ptitchef: 1e3,
+  goodfood: 1e3,
+  supertoinette: 3e3,
+  pequerecetas: 3e3
+};
+var PACED_SOURCES = Object.keys(PACING_FLOOR_MS);
+function pacingFor(source, configured) {
+  return Math.max(configured, PACING_FLOOR_MS[source] ?? SLOWEST_FLOOR_MS);
+}
+var SLOWEST_FLOOR_MS = Math.max(...Object.values(PACING_FLOOR_MS));
+function pacedConfig(config, source) {
+  return {
     userAgent: config.userAgent,
-    minIntervalMs: config.minIntervalMs,
+    minIntervalMs: pacingFor(source, config.minIntervalMs),
     timeoutMs: config.timeoutMs,
     maxRetries: config.maxRetries,
     cacheTtlMs: config.cacheTtlMs,
     cacheMaxEntries: config.cacheMaxEntries,
     logLevel: config.logLevel
   };
-  const marmitonOptions = { config: shared };
-  const cookbookOptions = { config: shared };
+}
+function buildSources(config, readers, logger) {
+  const paced = (source) => pacedConfig(config, source);
+  const marmitonOptions = { config: paced(MARMITON_PROFILE.id) };
+  const cookbookOptions = { config: paced(COOKBOOK_PROFILE.id) };
   const ptitchefOptions = {
-    config: { ...shared, ...PAGE_READ_BOUNDS },
+    config: { ...paced(PTITCHEF_PROFILE.id), ...PAGE_READ_BOUNDS },
+    logger
+  };
+  const goodfoodOptions = { config: paced(GOODFOOD_PROFILE.id), logger };
+  const supertoinetteOptions = {
+    config: paced(SUPERTOINETTE_PROFILE.id),
+    logger
+  };
+  const pequerecetasOptions = {
+    config: paced(PEQUERECETAS_PROFILE.id),
     logger
   };
-  const goodfoodOptions = { config: shared, logger };
-  const supertoinetteOptions = { config: shared, logger };
   return [
     marmitonAdapter(readers.marmiton ?? new MarmitonClient(marmitonOptions)),
     cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions)),
     ptitchefAdapter(readers.ptitchef ?? new PtitchefClient(ptitchefOptions)),
     goodfoodAdapter(readers.goodfood ?? new GoodFoodClient(goodfoodOptions)),
-    supertoinetteAdapter(readers.supertoinette ?? new SupertoinetteClient(supertoinetteOptions))
+    supertoinetteAdapter(readers.supertoinette ?? new SupertoinetteClient(supertoinetteOptions)),
+    pequerecetasAdapter(readers.pequerecetas ?? new PequerecetasClient(pequerecetasOptions))
   ];
 }
 function selectSources(sources, wanted) {
@@ -976,7 +1172,8 @@ var PROFILES = [
   COOKBOOK_PROFILE,
   PTITCHEF_PROFILE,
   GOODFOOD_PROFILE,
-  SUPERTOINETTE_PROFILE
+  SUPERTOINETTE_PROFILE,
+  PEQUERECETAS_PROFILE
 ];
 
 // src/sources/ids.ts
@@ -1133,6 +1330,84 @@ var FRENCH_FRAME = /* @__PURE__ */ new Set([
   "vous",
   "\xE0"
 ]);
+var SPANISH_FRAME = /* @__PURE__ */ new Set([
+  "algo",
+  "alguna",
+  "algunas",
+  "alguno",
+  "algunos",
+  "buenas",
+  "buenos",
+  "busco",
+  "buscar",
+  "casera",
+  "caseras",
+  "casero",
+  "caseros",
+  "como",
+  "conoces",
+  "cual",
+  "cuales",
+  "dame",
+  "de",
+  "del",
+  "dime",
+  "el",
+  "ella",
+  "ellos",
+  "en",
+  "es",
+  "esta",
+  "estoy",
+  "facil",
+  "faciles",
+  "gracias",
+  "hacer",
+  "hago",
+  "hay",
+  "hola",
+  "las",
+  "los",
+  "mas",
+  "me",
+  "mejor",
+  "mejores",
+  "necesito",
+  "para",
+  "pero",
+  "por",
+  "porfavor",
+  "puedes",
+  "que",
+  "queria",
+  "quiero",
+  "quisiera",
+  "receta",
+  "recetas",
+  "rica",
+  "ricas",
+  "rico",
+  "ricos",
+  "saber",
+  "sabes",
+  "se",
+  "sencilla",
+  "sencillas",
+  "sencillo",
+  "sencillos",
+  "ser",
+  "si",
+  "son",
+  "soy",
+  "tengo",
+  "tienes",
+  "un",
+  "una",
+  "unas",
+  "unos",
+  "y",
+  "yo"
+]);
 var ENGLISH_FRAME = /* @__PURE__ */ new Set([
   "a",
   "about",
@@ -1244,6 +1519,8 @@ var NEGATORS = /* @__PURE__ */ new Set([
   "pas",
   "sans",
   "sauf",
+  "sin",
+  "tampoco",
   "without",
   "zero"
 ]);
@@ -1265,7 +1542,12 @@ var HEALTH_MARKERS = /* @__PURE__ */ new Set([
   "intolerant",
   "intolerante",
   "intolerantes",
-  "intolerants"
+  "alergia",
+  "alergias",
+  "alergica",
+  "alergico",
+  "celiaca",
+  "celiaco"
 ]);
 var DIETS = /* @__PURE__ */ new Set([
   "casher",
@@ -1287,6 +1569,12 @@ var DIETS = /* @__PURE__ */ new Set([
   "vegetalienne",
   "vegetaliennes",
   "vegetaliens",
+  "vegana",
+  "veganas",
+  "veganos",
+  "vegetariana",
+  "vegetarianas",
+  "vegetarianos",
   "vegetarian",
   "vegetarians",
   "vegetarien",
@@ -1340,10 +1628,10 @@ function foldWord(word) {
   return word.toLowerCase().normalize("NFD").replace(new RegExp("\\p{M}+", "gu"), "").replace(/œ/gu, "oe");
 }
 function namesTheDish(word, key) {
-  if (FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key)) {
+  if (FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key) || SPANISH_FRAME.has(key)) {
     return false;
   }
-  if (FRENCH_FRAME.has(word) || ENGLISH_FRAME.has(word)) {
+  if (FRENCH_FRAME.has(word) || ENGLISH_FRAME.has(word) || SPANISH_FRAME.has(word)) {
     return false;
   }
   if (DIGITS_ONLY.test(word)) {
@@ -1451,7 +1739,7 @@ function takeFood(words, from) {
 }
 function isFiller(word) {
   const key = foldWord(word);
-  return CONDITION_JOINERS.has(key) || FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key);
+  return CONDITION_JOINERS.has(key) || FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key) || SPANISH_FRAME.has(key);
 }
 function namesFood(word) {
   const key = foldWord(word);
@@ -1473,7 +1761,7 @@ function namesFood(word) {
   if (CONDITION_UNITS.has(key)) {
     return false;
   }
-  return !(FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key));
+  return !(FRENCH_FRAME.has(key) || ENGLISH_FRAME.has(key) || SPANISH_FRAME.has(key));
 }
 function readConditions(question) {
   const { conditions } = readQuestion(question);
@@ -1547,6 +1835,7 @@ function tidy(value) {
 
 // src/sources/client.ts
 var LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+var LONGEST_WAIT_BETWEEN_TRIES_MS = 3e4;
 var MAX_LIMIT_PER_SOURCE = 25;
 function withGuarantees(config) {
   const defaults = loadConfig({});
@@ -1588,7 +1877,8 @@ function withDeadline(work, ms, source) {
   });
   return Promise.race([work, alarm]).finally(() => clearTimeout(timer));
 }
-function reportOf(attempt, count2) {
+function reportOf(attempt, rows, question) {
+  const count2 = rows.length;
   return {
     source: attempt.source.id,
     name: attempt.source.name,
@@ -1597,11 +1887,14 @@ function reportOf(attempt, count2) {
     reportedTotal: attempt.reportedTotal,
     reportedTotalMeans: attempt.reportedTotalMeans,
     skipped: attempt.skipped,
-    mixesReferencePages: attempt.source.mixesReferencePages,
+    rowsThatAreNotRecipes: attempt.source.rowsThatAreNotRecipes,
     cached: attempt.cached,
     error: attempt.error,
     wordings: attempt.wordings,
-    preferredByName: attempt.preferredByName
+    preferredByName: attempt.preferredByName,
+    // Counted over the rows this answer holds, so it is read against `count`
+    // and never against a number of rows nobody was shown.
+    namesTheDish: rows.filter((row) => namesDish(row.title, question)).length
   };
 }
 function heldBack(wording, because) {
@@ -1677,11 +1970,20 @@ var RecipesClient = class {
   }
   /**
    * The backstop deadline over one source, covering every attempt it is
-   * entitled to make and the pacing between them.
+   * entitled to make and the waiting between them.
+   *
+   * Three things a reader spends between two attempts, and all three belong
+   * here or this fires while the reader is still working: the spacing that
+   * source is read at, which is its own and not the shared setting; the backoff
+   * a reader adds after a failure; and the wait a site asks for by name when it
+   * answers "slow down". A deadline shorter than the reader's own abandons a
+   * read whose requests carry on reaching the site, and leaves that source's
+   * queue occupied behind an answer nobody waits for.
    */
-  get deadlineMs() {
+  deadlineFor(source) {
     const attempts = this.config.maxRetries + 1;
-    return this.config.timeoutMs * attempts + this.config.minIntervalMs * this.config.maxRetries;
+    const between = pacingFor(source, this.config.minIntervalMs) + LONGEST_WAIT_BETWEEN_TRIES_MS;
+    return this.config.timeoutMs * attempts + between * this.config.maxRetries;
   }
   /**
    * Ask every source the same question and merge the rows.
@@ -1710,7 +2012,7 @@ var RecipesClient = class {
     const answered = attempts.map((attempt) => ({ attempt, rows: attempt.rows.slice(0, limit) }));
     return {
       rows: interleave(answered.map((one) => one.rows)),
-      reports: answered.map(({ attempt, rows }) => reportOf(attempt, rows.length))
+      reports: answered.map(({ attempt, rows }) => reportOf(attempt, rows, trimmed))
     };
   }
   /**
@@ -1772,7 +2074,7 @@ var RecipesClient = class {
       try {
         const read = await withDeadline(
           source.search(wording.query, limit),
-          this.deadlineMs,
+          this.deadlineFor(source.id),
           source
         );
         answered = true;
@@ -1821,15 +2123,12 @@ var RecipesClient = class {
         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;
+    const onTopicRows = rows.filter((row) => namesDish(row.title, question));
+    const ordered = [...onTopicRows, ...rows.filter((row) => !namesDish(row.title, question))];
     return {
       source,
       rows: ordered,
-      preferredByName: contributing > 1,
+      preferredByName: true,
       cached,
       reportedTotal,
       reportedTotalMeans,
@@ -1850,7 +2149,7 @@ var RecipesClient = class {
     try {
       const outcome = await withDeadline(
         read.source.getRecipe(read.reference),
-        this.deadlineMs,
+        this.deadlineFor(read.source.id),
         read.source
       );
       return { recipe: outcome.recipe, cached: outcome.cached, read };
@@ -1866,21 +2165,194 @@ import { z as z4 } from "zod";
 // src/tools/recipeView.ts
 import { z as z2 } from "zod";
 
+// src/recipe/equipment.ts
+var LEADING_QUANTITY = /^\s*(?:\d+(?:[.,/]\d+)?|[¼½¾⅓⅔⅛])\s*/u;
+var LEADING_ARTICLE = /^(?:un|una|unos|unas|une|des|del|de|the|an?|le|la|los|las)\s+/iu;
+var WORD_SPLIT = /[\s,;:()]+/u;
+var TOOL_NOUNS = /* @__PURE__ */ new Set([
+  // Spanish
+  "freidora",
+  "airfryer",
+  "batidora",
+  "licuadora",
+  "amasadora",
+  "thermomix",
+  "robot",
+  "olla",
+  "paellera",
+  "cazuela",
+  "sarten",
+  "molde",
+  "rejilla",
+  "brocha",
+  "pincel",
+  "espatula",
+  "varilla",
+  "varillas",
+  "colador",
+  "escurridor",
+  "tamiz",
+  "mortero",
+  "rodillo",
+  "boquilla",
+  "termometro",
+  "temporizador",
+  "microondas",
+  "vaporera",
+  "parrilla",
+  "cuchillo",
+  "pelador",
+  "rallador",
+  "exprimidor",
+  "pinza",
+  "pinzas",
+  "cuenco",
+  "recipiente",
+  "batidor",
+  "prensa",
+  "palillo",
+  "palillos",
+  "brocheta",
+  "brochetas",
+  // French
+  "poele",
+  "cocotte",
+  "sauteuse",
+  "saladier",
+  "fouet",
+  "spatule",
+  "passoire",
+  "mixeur",
+  "mandoline",
+  "pinceau",
+  "casserole",
+  // English
+  "skillet",
+  "saucepan",
+  "whisk",
+  "spatula",
+  "sieve",
+  "colander",
+  "grater",
+  "blender",
+  "processor",
+  "ramekin",
+  "thermometer",
+  "peeler"
+]);
+var AMBIGUOUS_TOOL_NOUNS = {
+  papel: /^(?:hornear|horno|aluminio|film|vegetal|absorbente|cocina|parchment|baking)$/,
+  papier: /^(?:cuisson|sulfurise|aluminium|film)$/,
+  vaso: /^(?:medidor|batidora|thermomix)$/,
+  cuchara: /^(?:madera|silicona|helado)$/,
+  manga: /^(?:pastelera)$/,
+  tabla: /^(?:cortar|madera)$/,
+  plancha: /^(?:electrica|hierro)$/,
+  horno: /^(?:precalentado)$/,
+  bol: /^(?:grande|mediano|pequeno|hondo|cristal|acero)$/,
+  plato: /^(?:hondo|llano|grande)$/,
+  bandeja: /^(?:horno|hornear|pastelera)$/,
+  fuente: /^(?:horno|hornear|cristal)$/,
+  film: /^(?:transparente|plastico|alimentario)$/,
+  moule: /^(?:tarte|manque|cake|silicone|charniere)$/,
+  plat: /^(?:four|gratin|cuisson)$/,
+  plaque: /^(?:four|cuisson|patisserie)$/,
+  planche: /^(?:decouper|bois)$/,
+  tin: /^(?:baking|cake|loaf|roasting|flan|sandwich)$/,
+  pan: /^(?:frying|baking|roasting|cake|loaf|sauce|griddle)$/,
+  dish: /^(?:baking|roasting|ovenproof|gratin)$/,
+  tray: /^(?:baking|roasting|oven)$/,
+  sheet: /^(?:baking|greaseproof|parchment)$/,
+  bowl: /^(?:mixing|large|small)$/,
+  mould: /^(?:cake|jelly|silicone)$/,
+  mold: /^(?:cake|jelly|silicone)$/,
+  paper: /^(?:baking|greaseproof|parchment)$/,
+  foil: /^(?:aluminium|aluminum|kitchen)$/,
+  board: /^(?:chopping|cutting|wooden)$/
+};
+var QUALIFIES_A_TOOL = /^(?:aire|hornear|horno|cocina|madera|silicona|silicone|barro|cristal|acero|hierro|aluminio|aluminium|plastico|papel|cortar|decouper|bois|varillas|mano|repostera|pasteleria|pastelera|tarte|manque|four|cuisson|gratin|patisserie|baking|frying|roasting|chopping|cutting|mixing|greaseproof|parchment|nonstick|cake|loaf|wooden|\d+|cm|mm|l|ml)$/;
+var PARTITIVE = /^(?:de|del|du|des|d|a|au|à)$/i;
+function fold2(word) {
+  return word.normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/œ/g, "oe").toLowerCase();
+}
+function holds(vocabulary, word) {
+  if (vocabulary.has(word)) {
+    return true;
+  }
+  if (word.endsWith("es") && vocabulary.has(word.slice(0, -2))) {
+    return true;
+  }
+  return word.endsWith("s") && vocabulary.has(word.slice(0, -1));
+}
+function isEquipmentLine(line) {
+  const head = line.replace(LEADING_QUANTITY, "").replace(LEADING_ARTICLE, "").trim();
+  const words = head.split(WORD_SPLIT).filter((word) => word !== "");
+  const first = words[0];
+  if (first === void 0) {
+    return false;
+  }
+  const folded = fold2(first);
+  if (holds(TOOL_NOUNS, folded)) {
+    return notMeasuringSomethingElse(words);
+  }
+  const ambiguous = qualifierFor(folded);
+  if (ambiguous) {
+    return ambiguous.test(wordBeside(words, 0));
+  }
+  const second = words[1];
+  if (second !== void 0 && QUALIFIES_A_TOOL.test(folded)) {
+    const behind = qualifierFor(fold2(second));
+    return behind ? behind.test(folded) : holds(TOOL_NOUNS, fold2(second));
+  }
+  return false;
+}
+function qualifierFor(word) {
+  return AMBIGUOUS_TOOL_NOUNS[word] ?? (word.endsWith("es") ? AMBIGUOUS_TOOL_NOUNS[word.slice(0, -2)] : void 0) ?? (word.endsWith("s") ? AMBIGUOUS_TOOL_NOUNS[word.slice(0, -1)] : void 0);
+}
+function wordAt(words, index) {
+  const word = words[index];
+  return word === void 0 ? "" : fold2(word);
+}
+function wordBeside(words, index) {
+  const next = wordAt(words, index + 1);
+  return PARTITIVE.test(next) ? wordAt(words, index + 2) : next;
+}
+function notMeasuringSomethingElse(words) {
+  const after = words[1];
+  if (after === void 0 || !PARTITIVE.test(fold2(after))) {
+    return true;
+  }
+  return QUALIFIES_A_TOOL.test(wordAt(words, 2));
+}
+var EQUIPMENT_NOTE = "This line names a tool, so it was left as published: a recipe made for more people uses the same one.";
+
 // src/recipe/language.ts
-var FRENCH_WORDS = /(?:^|[\s(])(?:de|du|des|à|au|aux|la|le|les|un|une|quelques|dans|avec|sans|pour|selon|environ)(?=[\s),.]|$)|\bd'|\bl'|\bqu'/iu;
+var FRENCH_WORDS = /(?:^|[\s(])(?:du|des|à|au|aux|le|les|une|quelques|dans|avec|sans|pour|selon|environ)(?=[\s),.]|$)|\bd'|\bl'|\bqu'/iu;
 var ENGLISH_WORDS = /(?:^|[\s(])(?:of|an|the|and|with|without|for|into|about|each|per|plus|freshly|finely|roughly|coarsely|optional)(?=[\s),.]|$)/iu;
-var FRENCH_LETTERS = /[àâäçéèêëîïôöùûüœ]/iu;
-var FRENCH_FOODS = /\b(?:oeufs?|œufs?|sel|poivre|sucres?|farine|beurre|lait|crème|creme|huile|ail|oignons?|fromage|pain|poulet|boeuf|bœuf|riz|pâtes|pates|jambon|citrons?|pommes?|vin|eau|persil|thym|miel|jaunes?|blancs?)\b/iu;
+var SPANISH_WORDS = /(?:^|[\s(])(?:del|el|los|las|una|unos|unas|con|sin|para|al|y|según|aproximadamente|picad[oa]s?|tro?cead[oa]s?|rallad[oa]s?|molid[oa]s?|cortad[oa]s?|pelad[oa]s?|opcional)(?=[\s),.]|$)/iu;
+var ROMANCE_WORDS = /(?:^|[\s(])(?:de|la|un|en)(?=[\s),.]|$)/iu;
+var FRENCH_LETTERS = /[àâçèêëîïôùûœ]/iu;
+var SPANISH_LETTERS = /[áíóúñ¿¡]/iu;
+var ROMANCE_LETTERS = /[éü]/iu;
+var FRENCH_FOODS = /\b(?:oeufs?|œufs?|sel|poivre|sucres?|farine|beurre|lait|crème|creme|huile|ail|oignons?|fromage|pain|poulet|boeuf|bœuf|riz|pâtes|pates|jambon|citrons?|pommes?|vin|eau|persil|thym|jaunes?|blancs?)\b/iu;
 var ENGLISH_FOODS = /\b(?:eggs?|salt|pepper|sugar|flour|butter|milk|cream|oil|garlic|onions?|cheese|bread|chicken|beef|rice|pasta|ham|lemons?|apples?|wine|water|parsley|thyme|honey|yolks?|whites?)\b/iu;
+var SPANISH_FOODS = /\b(?:huevos?|sal|pimienta|azúcar|azucar|harina|mantequilla|leche|nata|aceite|ajos?|cebollas?|queso|pollo|ternera|cerdo|arroz|jamón|jamon|limones|limón|limon|manzanas?|patatas?|vino|agua|perejil|tomillo|yemas?|claras?)\b/iu;
 var STRUCTURAL = 3;
 var VOCABULARY = 2;
 var NAME = 1;
-function readLanguage(line, evidence = {
-  frenchUnit: false,
-  englishUnit: false
-}) {
+var NO_UNIT = { frenchUnit: false, englishUnit: false, spanishUnit: false };
+function readLanguage(line, evidence = NO_UNIT) {
   let french = 0;
   let english = 0;
+  let spanish = 0;
+  if (ROMANCE_WORDS.test(line)) {
+    french += STRUCTURAL;
+    spanish += STRUCTURAL;
+  }
+  if (ROMANCE_LETTERS.test(line)) {
+    french += STRUCTURAL;
+    spanish += STRUCTURAL;
+  }
   if (FRENCH_WORDS.test(line)) {
     french += STRUCTURAL;
   }
@@ -1890,19 +2362,40 @@ function readLanguage(line, evidence = {
   if (ENGLISH_WORDS.test(line)) {
     english += STRUCTURAL;
   }
+  if (SPANISH_WORDS.test(line)) {
+    spanish += STRUCTURAL;
+  }
+  if (SPANISH_LETTERS.test(line)) {
+    spanish += STRUCTURAL;
+  }
   if (evidence.frenchUnit) {
     french += VOCABULARY;
   }
   if (evidence.englishUnit) {
     english += VOCABULARY;
   }
+  if (evidence.spanishUnit) {
+    spanish += VOCABULARY;
+  }
   if (FRENCH_FOODS.test(line)) {
     french += NAME;
   }
   if (ENGLISH_FOODS.test(line)) {
     english += NAME;
   }
-  return { language: french > english ? "fr" : "en", french, english };
+  if (SPANISH_FOODS.test(line)) {
+    spanish += NAME;
+  }
+  return { language: winner(french, english, spanish), french, english, spanish };
+}
+function winner(french, english, spanish) {
+  if (french >= spanish && french > english) {
+    return "fr";
+  }
+  if (spanish > english) {
+    return "es";
+  }
+  return "en";
 }
 
 // src/recipe/units.ts
@@ -1912,10 +2405,14 @@ var EAUX_ENDING = /eaux$/i;
 var EAU_ENDING = /eau$/i;
 var FUL_MEASURE = /^[a-z]{3,}fuls?$/;
 var HEAD_BEFORE_DE = new RegExp("^\\s*(\\p{L}+)\\s+(?=(?:de|du|des)\\s|d')", "u");
-var HOUSEHOLD_MEASURE = /^(cup|tablespoon|Tbsp|teaspoon|tsp|cuillère à soupe|cuillère à café|tasse)$/;
+var HOUSEHOLD_MEASURE = /^(cup|tablespoon|Tbsp|teaspoon|tsp|cuillère à soupe|cuillère à café|tasse|taza|cucharada|cucharadita|cda|cdta)$/;
 var SIBILANT_LETTER = /[sxz]$/i;
 var TRAILING_S_ANY_CASE = /s$/i;
 var VOWEL_THEN_S = /[aiou]s$/i;
+var INVARIABLE_SPANISH = /(?:is|us)$/i;
+var ES_ENDING = /(?:[^aeiouáéíóú]es)$/i;
+var SPANISH_VOWEL_ENDING = /[aeiouáéíóú]$/i;
+var Z_ENDING = /z$/i;
 var SHARED_UNITS = {
   mg: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
   g: { canonical: "g", kind: "measured", system: "metric", symbol: true },
@@ -2197,9 +2694,102 @@ var ENGLISH_UNITS = {
   knob: { canonical: "knob", kind: "approximate", system: "none" },
   knobs: { canonical: "knob", kind: "approximate", system: "none" }
 };
+var SPANISH_UNITS = {
+  ...SHARED_UNITS,
+  gramo: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  gramos: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kilogramo: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilogramos: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  litro: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  litros: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  mililitro: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  mililitros: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  decilitro: { canonical: "dl", kind: "measured", system: "metric", symbol: true },
+  decilitros: { canonical: "dl", kind: "measured", system: "metric", symbol: true },
+  centilitro: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  centilitros: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  // A page glossing a metric weight names the pound and the ounce, which
+  // Spanish writes in full.
+  libra: { canonical: "libra", kind: "measured", system: "imperial", plural: "libras" },
+  libras: { canonical: "libra", kind: "measured", system: "imperial", plural: "libras" },
+  onza: { canonical: "onza", kind: "measured", system: "imperial", plural: "onzas" },
+  onzas: { canonical: "onza", kind: "measured", system: "imperial", plural: "onzas" },
+  // Spoons and cups: real measures, but only in sensible fractions.
+  cucharada: { canonical: "cucharada", kind: "portioned", system: "none", plural: "cucharadas" },
+  cucharadas: { canonical: "cucharada", kind: "portioned", system: "none", plural: "cucharadas" },
+  cda: { canonical: "cda", kind: "portioned", system: "none", symbol: true },
+  cdas: { canonical: "cda", kind: "portioned", system: "none", symbol: true },
+  "c s": { canonical: "cucharada", kind: "portioned", system: "none", plural: "cucharadas" },
+  cucharadita: {
+    canonical: "cucharadita",
+    kind: "portioned",
+    system: "none",
+    plural: "cucharaditas"
+  },
+  cucharaditas: {
+    canonical: "cucharadita",
+    kind: "portioned",
+    system: "none",
+    plural: "cucharaditas"
+  },
+  cdta: { canonical: "cdta", kind: "portioned", system: "none", symbol: true },
+  cdtas: { canonical: "cdta", kind: "portioned", system: "none", symbol: true },
+  "c p": { canonical: "cucharadita", kind: "portioned", system: "none", plural: "cucharaditas" },
+  taza: { canonical: "taza", kind: "portioned", system: "none", plural: "tazas" },
+  tazas: { canonical: "taza", kind: "portioned", system: "none", plural: "tazas" },
+  vaso: { canonical: "vaso", kind: "portioned", system: "none" },
+  vasos: { canonical: "vaso", kind: "portioned", system: "none" },
+  // Packaging and natural units: countable, so they round to whole things.
+  sobre: { canonical: "sobre", kind: "portioned", system: "none" },
+  sobres: { canonical: "sobre", kind: "portioned", system: "none" },
+  diente: { canonical: "diente", kind: "portioned", system: "none" },
+  dientes: { canonical: "diente", kind: "portioned", system: "none" },
+  lata: { canonical: "lata", kind: "portioned", system: "none", plural: "latas" },
+  latas: { canonical: "lata", kind: "portioned", system: "none", plural: "latas" },
+  bote: { canonical: "bote", kind: "portioned", system: "none" },
+  botes: { canonical: "bote", kind: "portioned", system: "none" },
+  tarro: { canonical: "tarro", kind: "portioned", system: "none" },
+  tarros: { canonical: "tarro", kind: "portioned", system: "none" },
+  paquete: { canonical: "paquete", kind: "portioned", system: "none" },
+  paquetes: { canonical: "paquete", kind: "portioned", system: "none" },
+  loncha: { canonical: "loncha", kind: "portioned", system: "none", plural: "lonchas" },
+  lonchas: { canonical: "loncha", kind: "portioned", system: "none", plural: "lonchas" },
+  rebanada: { canonical: "rebanada", kind: "portioned", system: "none", plural: "rebanadas" },
+  rebanadas: { canonical: "rebanada", kind: "portioned", system: "none", plural: "rebanadas" },
+  rodaja: { canonical: "rodaja", kind: "portioned", system: "none", plural: "rodajas" },
+  rodajas: { canonical: "rodaja", kind: "portioned", system: "none", plural: "rodajas" },
+  hoja: { canonical: "hoja", kind: "portioned", system: "none", plural: "hojas" },
+  hojas: { canonical: "hoja", kind: "portioned", system: "none", plural: "hojas" },
+  rama: { canonical: "rama", kind: "portioned", system: "none", plural: "ramas" },
+  ramas: { canonical: "rama", kind: "portioned", system: "none", plural: "ramas" },
+  ramita: { canonical: "ramita", kind: "portioned", system: "none", plural: "ramitas" },
+  ramitas: { canonical: "ramita", kind: "portioned", system: "none", plural: "ramitas" },
+  manojo: { canonical: "manojo", kind: "portioned", system: "none" },
+  manojos: { canonical: "manojo", kind: "portioned", system: "none" },
+  unidad: { canonical: "unidad", kind: "portioned", system: "none", plural: "unidades" },
+  unidades: { canonical: "unidad", kind: "portioned", system: "none", plural: "unidades" },
+  // Held to no better than a hand: the count scales, the size of one does not.
+  pizca: { canonical: "pizca", kind: "approximate", system: "none", plural: "pizcas" },
+  pizcas: { canonical: "pizca", kind: "approximate", system: "none", plural: "pizcas" },
+  punado: { canonical: "pu\xF1ado", kind: "approximate", system: "none", plural: "pu\xF1ados" },
+  punados: { canonical: "pu\xF1ado", kind: "approximate", system: "none", plural: "pu\xF1ados" },
+  chorro: { canonical: "chorro", kind: "approximate", system: "none" },
+  chorros: { canonical: "chorro", kind: "approximate", system: "none" },
+  chorrito: { canonical: "chorrito", kind: "approximate", system: "none" },
+  chorritos: { canonical: "chorrito", kind: "approximate", system: "none" },
+  gota: { canonical: "gota", kind: "approximate", system: "none", plural: "gotas" },
+  gotas: { canonical: "gota", kind: "approximate", system: "none", plural: "gotas" },
+  cazo: { canonical: "cazo", kind: "approximate", system: "none" },
+  cazos: { canonical: "cazo", kind: "approximate", system: "none" },
+  cucharon: { canonical: "cuchar\xF3n", kind: "approximate", system: "none", plural: "cucharones" },
+  cucharones: { canonical: "cuchar\xF3n", kind: "approximate", system: "none", plural: "cucharones" },
+  toque: { canonical: "toque", kind: "approximate", system: "none" },
+  toques: { canonical: "toque", kind: "approximate", system: "none" }
+};
 var VOCABULARY2 = {
   fr: FRENCH_UNITS,
-  en: ENGLISH_UNITS
+  en: ENGLISH_UNITS,
+  es: SPANISH_UNITS
 };
 function normalizeUnitKey(text2) {
   return text2.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\./g, " ").replace(/\((?:s|x|es)\)/g, "").replace(/\s+/g, " ").trim();
@@ -2211,7 +2801,8 @@ function orderedKeys(vocabulary) {
 }
 var UNIT_KEYS = {
   fr: orderedKeys(FRENCH_UNITS),
-  en: orderedKeys(ENGLISH_UNITS)
+  en: orderedKeys(ENGLISH_UNITS),
+  es: orderedKeys(SPANISH_UNITS)
 };
 function unitKeys(language) {
   return UNIT_KEYS[language];
@@ -2221,7 +2812,8 @@ function lookupUnit(text2, language) {
 }
 var EMBEDDED = {
   fr: buildEmbedded("fr"),
-  en: buildEmbedded("en")
+  en: buildEmbedded("en"),
+  es: buildEmbedded("es")
 };
 function buildEmbedded(language) {
   const keys = UNIT_KEYS[language].map((key) => key.replace(/ /g, "\\s+"));
@@ -2248,7 +2840,7 @@ var NOT_A_MEASURE = /* @__PURE__ */ new Set([
   "melange",
   "ensemble"
 ]);
-function readPartitiveMeasure(text2) {
+function readPartitiveMeasure(text2, language) {
   const match = HEAD_BEFORE_DE.exec(text2);
   if (!match) {
     return null;
@@ -2260,16 +2852,16 @@ function readPartitiveMeasure(text2) {
   if (NOT_A_MEASURE.has(normalizeUnitKey(word))) {
     return null;
   }
-  if (lookupUnit(word, "fr")) {
+  if (lookupUnit(word, language)) {
     return null;
   }
-  const canonical = frenchSingular(word);
+  const canonical = language === "es" ? spanishSingular(word) : frenchSingular(word);
   return {
     unit: {
       canonical,
       kind: "approximate",
       system: "none",
-      plural: frenchPlural(canonical)
+      plural: language === "es" ? spanishPlural(canonical) : frenchPlural(canonical)
     },
     rest: text2.slice(match[0].length)
   };
@@ -2297,6 +2889,30 @@ function frenchSingular(word) {
   }
   return word;
 }
+function spanishSingular(word) {
+  if (INVARIABLE_SPANISH.test(word)) {
+    return word;
+  }
+  if (ES_ENDING.test(word) && word.length > 4) {
+    return word.slice(0, -2);
+  }
+  if (TRAILING_S_ANY_CASE.test(word) && word.length > 3) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function spanishPlural(word) {
+  if (INVARIABLE_SPANISH.test(word)) {
+    return word;
+  }
+  if (SPANISH_VOWEL_ENDING.test(word)) {
+    return `${word}s`;
+  }
+  if (Z_ENDING.test(word)) {
+    return `${word.slice(0, -1)}ces`;
+  }
+  return `${word}es`;
+}
 function frenchPlural(word) {
   if (SIBILANT_LETTER.test(word)) {
     return word;
@@ -2326,7 +2942,13 @@ var APPROXIMATE_EQUIVALENT = {
   filet: "commonly taken as about a teaspoon poured in a thin line",
   noix: "commonly taken as about a tablespoon of butter",
   louche: "commonly taken as about half a cup",
-  soupcon: "commonly taken as the smallest amount a spoon tip carries"
+  soupcon: "commonly taken as the smallest amount a spoon tip carries",
+  pizca: "commonly taken as about half a teaspoon",
+  punado: "commonly taken as about a quarter of a cup",
+  chorrito: "commonly taken as about a teaspoon poured in a thin line",
+  chorro: "commonly taken as about a tablespoon poured free-hand",
+  gota: "commonly taken as a single drop",
+  cucharon: "commonly taken as about half a cup"
 };
 function approximateEquivalent(unit) {
   return APPROXIMATE_EQUIVALENT[normalizeUnitKey(unit.canonical)] ?? null;
@@ -2354,6 +2976,9 @@ var DEMOTIONS = {
   tbsp: { to: "tsp", per: 3, language: "en" },
   "cuillere a soupe": { to: "cuillere a cafe", per: 3, language: "fr" },
   tasse: { to: "cuillere a soupe", per: 16, language: "fr" },
+  cucharada: { to: "cucharadita", per: 3, language: "es" },
+  cda: { to: "cdta", per: 3, language: "es" },
+  taza: { to: "cucharada", per: 16, language: "es" },
   kg: { to: "g", per: 1e3, language: "en" },
   g: { to: "mg", per: 1e3, language: "en" },
   l: { to: "cl", per: 100, language: "en" },
@@ -2382,7 +3007,7 @@ function unitDivisibility(unit) {
   }
   return QUARTERED_MEASURE.test(unit.canonical) ? "quarter" : "half";
 }
-var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|tranches?|slices?)\b/i;
+var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|tranches?|slices?|botes?|tarros?|botellas?|bloques?|lonchas?|rebanadas?|rodajas?)\b/i;
 function countsBarePieces(unit) {
   return unit.canonical === "ea";
 }
@@ -2429,17 +3054,22 @@ function formatUnit(unit, amount, language) {
   if (singular) {
     return unit.canonical;
   }
-  return unit.plural ?? `${unit.canonical}s`;
+  if (unit.plural) {
+    return unit.plural;
+  }
+  return language === "es" ? spanishPlural(unit.canonical) : `${unit.canonical}s`;
 }
 
 // src/recipe/quantity.ts
 var BRACKETED_TAIL = /\s*(\([^()]*\))\s*$/;
-var LEADING_ARTICLE = /^(?:of\s+)?an?\s+/i;
+var LEADING_ARTICLE2 = /^(?:of\s+)?an?\s+/i;
 var LEADING_ARTICLE_FRENCH = /^(?:une|un)\s+/i;
 var LEADING_INDEFINITE_WITH_SPACE = /^an?\s+/i;
 var LEADING_PARTITIVE = /^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i;
 var OF_OPENING = /^of\s+/i;
 var OPENING_ARTICLE_FRENCH = /^\s*(un|une)\b\s*/i;
+var OPENING_ARTICLE_SPANISH = /^\s*(un|una)\b\s*/i;
+var LEADING_ARTICLE_SPANISH = /^(?:una|un)\s+/i;
 var REPEATED_COMMA_GROUPS = /^\s*\d+,\d+,\d/;
 var SLASH_OUTSIDE_A_FRACTION = /(?<!\d)\/|\/(?!\d)/;
 var ATTACHED_DE = /\s+de\s+(?=\d)/i;
@@ -2448,19 +3078,47 @@ var DIGIT = /\d/;
 var ENGLISH_RANGE_JOINER = /^\s+(to|or)\s+/i;
 var FRACTION_WORD = /^(?:(a|an|one|two|three)[\s-]+)?(halves|half|thirds|third|quarters|quarter|fourths|fourth)\b/i;
 var FRENCH_RANGE_JOINER = /^\s+(à|a|ou)\s+/i;
+var SPANISH_RANGE_JOINER = /^\s+(a|o)\s+/i;
+var SPANISH_FRACTION_WORD = /^(?:medi[oa]s?\b|(?:(un|una|dos|tres)\s+)?(cuartos|cuarto|tercios|tercio|mitad(?:es)?)\b)/i;
 var GROUPED_DECIMAL = /^(\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:\.\d+)?)/;
+function writesDecimalComma(language) {
+  return language !== "en";
+}
+function usesPartitiveDe(language) {
+  return language !== "en";
+}
+var OPENING_ARTICLE_ROMANCE = {
+  en: OPENING_ARTICLE_FRENCH,
+  fr: OPENING_ARTICLE_FRENCH,
+  es: OPENING_ARTICLE_SPANISH
+};
+var ROMANCE_ARTICLE = {
+  en: LEADING_ARTICLE_FRENCH,
+  fr: LEADING_ARTICLE_FRENCH,
+  es: LEADING_ARTICLE_SPANISH
+};
+var RANGE_JOINER = {
+  en: ENGLISH_RANGE_JOINER,
+  fr: FRENCH_RANGE_JOINER,
+  es: SPANISH_RANGE_JOINER
+};
+var OTHER_LANGUAGES = {
+  en: ["fr", "es"],
+  fr: ["es", "en"],
+  es: ["fr", "en"]
+};
 var HYPHENATED_TAIL = new RegExp("^-\\p{L}", "u");
 var LEADING_DASH = /^\s*(–|—|-)\s*/;
 var LEADING_INDEFINITE = /^an?\s/i;
 var LEADING_OF = /^\s*of\s+/i;
-var LEADING_QUANTITY = /^[\s\d.,/½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞\-–—]+/u;
+var LEADING_QUANTITY2 = /^[\s\d.,/½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞\-–—]+/u;
 var LEADING_WORD = new RegExp("^\\s*(\\p{L}+)\\s+", "u");
 var MIXED_FRACTION = /^(\d+)\s+(\d+)\s*\/\s*(\d+)/;
 var PARTITIVE_BEFORE_BRACKET = /^(?:de\s+|du\s+|des\s+|d'|of\s+)(?=\()/i;
 var PARTITIVE_OPENING = /^(?:de\s|d'|du\s|des\s|,)/i;
 var SIMPLE_FRACTION = /^(\d+)\s*\/\s*(\d+)/;
 var TRAILING_S = /s$/;
-var VAGUE_ARTICLE = /^(?:un|une|quelques|of\s+an?|an?)\s+/iu;
+var VAGUE_ARTICLE = /^(?:une|unas|unos|una|un|quelques|of\s+an?|an?)\s+/iu;
 var WHITESPACE = /\s+/;
 function leadingMeasure(direct, behind) {
   if (direct.unit) {
@@ -2543,10 +3201,11 @@ function readable(text2) {
 }
 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
+  fr: /^(?:~|\u2248|environ|approximativement|\u00e0 peu pr\u00e8s|a peu pres)\s*/i,
+  es: /^(?:~|≈|unos|unas|aproximadamente|alrededor de|más o menos|mas o menos|como)\s*/i
 };
 var CONTAINER_CONTENTS = /^\s*(?:de\s|d'|du\s|des\s)/i;
-function statesItemSize(item) {
+function statesItemSize(item, language) {
   const attached = ATTACHED_DE.exec(item);
   if (!attached) {
     return false;
@@ -2555,14 +3214,14 @@ function statesItemSize(item) {
   if (!named || DIGIT.test(named)) {
     return false;
   }
-  return isStatedSize(item.slice(attached.index + attached[0].length));
+  return isStatedSize(item.slice(attached.index + attached[0].length), language);
 }
-function isStatedSize(text2) {
-  const size = parseLeadingQuantity(text2, "fr");
+function isStatedSize(text2, language) {
+  const size = parseLeadingQuantity(text2, language);
   if (!size) {
     return false;
   }
-  const measure = takeUnit(text2.slice(size.length).trimStart(), "fr");
+  const measure = takeUnit(text2.slice(size.length).trimStart(), language);
   if (measure.unit?.kind !== "measured") {
     return false;
   }
@@ -2613,12 +3272,20 @@ function namesContainer(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
+  fr: /^(?:h|mn|heures?|mins?|minutes?|secs?|secondes?|jours?|nuits?|semaines?)\b/i,
+  es: /^(?:h|hs|horas?|mins?|minutos?|segs?|segundos?|días?|dias?|noches?|semanas?)\b/i
 };
+function statesAnAmountPerEater(text2) {
+  return Object.values(PER_PERSON).some((pattern) => pattern.test(text2));
+}
+function namesALengthOfTime(text2) {
+  return Object.values(TIME_UNIT).some((pattern) => pattern.test(text2));
+}
 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
+  fr: /\bpar\s+(?:personne|convive|part|t\u00eate)\b/i,
+  es: /\bpor\s+(?:persona|comensal|ración|racion)\b/i
 };
 var MEASURE_ADJECTIVES = {
   en: /* @__PURE__ */ new Set([
@@ -2644,6 +3311,24 @@ var MEASURE_ADJECTIVES = {
     "grosse",
     "petit",
     "petite"
+  ]),
+  es: /* @__PURE__ */ new Set([
+    "buen",
+    "buena",
+    "colmada",
+    "colmado",
+    "escasa",
+    "escaso",
+    "generosa",
+    "generoso",
+    "gran",
+    "grande",
+    "mediana",
+    "mediano",
+    "peque\xF1a",
+    "peque\xF1o",
+    "rasa",
+    "raso"
   ])
 };
 function takeMeasureAdjective(text2, language) {
@@ -2692,25 +3377,33 @@ function parseLeadingQuantity(text2, language) {
   if (glyph && glyph in VULGAR_FRACTIONS) {
     return { amount: VULGAR_FRACTIONS[glyph] ?? Number.NaN, length: offset + 1 };
   }
-  const decimal = (language === "fr" ? DECIMAL : GROUPED_DECIMAL).exec(trimmed);
+  const decimal = (writesDecimalComma(language) ? DECIMAL : GROUPED_DECIMAL).exec(trimmed);
   if (decimal) {
-    const [written = ""] = decimal.slice(1);
+    const [written2 = ""] = decimal.slice(1);
     const amount = Number(
-      language === "fr" ? written.replace(",", ".") : written.replace(/,/g, "")
+      writesDecimalComma(language) ? written2.replace(",", ".") : written2.replace(/,/g, "")
     );
     if (Number.isFinite(amount)) {
       return { amount, length: offset + decimal[0].length };
     }
   }
-  if (language === "en") {
-    const written = parseWrittenFraction(trimmed);
-    if (written) {
-      return { amount: written.amount, length: offset + written.length };
-    }
+  const written = language === "es" ? parseSpanishFraction(trimmed) : parseWrittenFraction(trimmed, language);
+  if (written) {
+    return { amount: written.amount, length: offset + written.length };
   }
   return null;
 }
-var WRITTEN_NUMERATORS = { a: 1, an: 1, one: 1, two: 2, three: 3 };
+var WRITTEN_NUMERATORS = {
+  a: 1,
+  an: 1,
+  one: 1,
+  two: 2,
+  three: 3,
+  un: 1,
+  una: 1,
+  dos: 2,
+  tres: 3
+};
 var WRITTEN_DENOMINATORS = {
   half: 2,
   halves: 2,
@@ -2719,9 +3412,18 @@ var WRITTEN_DENOMINATORS = {
   quarter: 4,
   quarters: 4,
   fourth: 4,
-  fourths: 4
+  fourths: 4,
+  cuarto: 4,
+  cuartos: 4,
+  tercio: 3,
+  tercios: 3,
+  mitad: 2,
+  mitades: 2
 };
-function parseWrittenFraction(text2) {
+function parseWrittenFraction(text2, language) {
+  if (language !== "en") {
+    return null;
+  }
   const match = FRACTION_WORD.exec(text2);
   if (!match) {
     return null;
@@ -2737,13 +3439,29 @@ function parseWrittenFraction(text2) {
   }
   return { amount: numerator / denominator, length: match[0].length };
 }
+function parseSpanishFraction(text2) {
+  const match = SPANISH_FRACTION_WORD.exec(text2);
+  if (!match) {
+    return null;
+  }
+  const numerator = match[1] ? WRITTEN_NUMERATORS[match[1].toLowerCase()] : 1;
+  const denominator = match[2] ? WRITTEN_DENOMINATORS[match[2].toLowerCase()] : 2;
+  if (!(numerator && denominator)) {
+    return null;
+  }
+  const rest = text2.slice(match[0].length).replace(LEADING_PARTITIVE, "").trimStart();
+  if (rest === "") {
+    return null;
+  }
+  return { amount: numerator / denominator, length: match[0].length };
+}
 function parseLeadingRange(text2, language) {
   const low = parseLeadingQuantity(text2, language);
   if (!low) {
     return null;
   }
   const after = text2.slice(low.length);
-  const written = language === "fr" ? FRENCH_RANGE_JOINER : ENGLISH_RANGE_JOINER;
+  const written = RANGE_JOINER[language];
   const separator = written.exec(after) ?? LEADING_DASH.exec(after);
   if (!separator) {
     return null;
@@ -2759,7 +3477,7 @@ function parseLeadingRange(text2, language) {
     length: low.length + separator[0].length + high.length
   };
 }
-var FRENCH_ARTICLES = { un: 1, une: 1 };
+var ROMANCE_ARTICLES = { un: 1, une: 1, una: 1 };
 function takeUnit(text2, language) {
   const normalized = normalizeUnitKey(text2);
   for (const key of unitKeys(language)) {
@@ -2795,35 +3513,57 @@ function afterKey(text2, key) {
   }
   return null;
 }
-function takeUnitEitherLanguage(text2, language) {
+function takeUnitAnyLanguage(text2, language) {
   const first = takeUnit(text2, language);
   if (first.unit) {
     return first;
   }
-  return takeUnit(text2, language === "fr" ? "en" : "fr");
+  for (const other of OTHER_LANGUAGES[language]) {
+    const taken = takeUnit(text2, other);
+    if (taken.unit) {
+      return taken;
+    }
+  }
+  return first;
+}
+function detectLanguage(line) {
+  return readEvidence(line).language;
 }
 function readEvidence(line) {
   const text2 = line.trim();
-  const afterFigures = text2.replace(LEADING_QUANTITY, "").trimStart();
+  const afterFigures = text2.replace(LEADING_QUANTITY2, "").trimStart();
   const afterArticle = afterFigures.replace(VAGUE_ARTICLE, "");
   const frenchUnit = takeUnit(afterArticle, "fr").unit !== null;
   const englishUnit = takeUnit(afterArticle, "en").unit !== null;
-  return readLanguage(text2, { frenchUnit, englishUnit });
+  const spanishUnit = takeUnit(afterArticle, "es").unit !== null;
+  return readLanguage(text2, { frenchUnit, englishUnit, spanishUnit });
 }
 function readMeasure(rest, language, fromArticle) {
   const direct = takeLeadingUnit(rest, language, fromArticle);
-  const described = direct.unit ? { adjective: null, rest } : takeMeasureAdjective(rest, language);
+  if (direct.unit) {
+    const following = language === "es" ? takeMeasureAdjective(direct.rest, language) : null;
+    if (following?.adjective) {
+      return {
+        leading: { ...direct, rest: following.rest },
+        described: { adjective: following.adjective, rest: direct.rest },
+        behind: direct,
+        follows: true
+      };
+    }
+    return { leading: direct, described: { adjective: null, rest }, behind: null, follows: false };
+  }
+  const described = takeMeasureAdjective(rest, language);
   const behind = described.adjective ? takeLeadingUnit(described.rest, language, fromArticle) : null;
-  return { leading: leadingMeasure(direct, behind), described, behind };
+  return { leading: leadingMeasure(direct, behind), described, behind, follows: false };
 }
-function whatTheFigureIsNot(behindFigure, couldBeARank, language) {
+function whatTheFigureIsNot(behindFigure, couldBeARank) {
   if (HYPHENATED_TAIL.test(behindFigure)) {
     return "sizeQualifier";
   }
   if (couldBeARank && ORDINAL_SUFFIX.test(behindFigure)) {
     return null;
   }
-  if (TIME_UNIT[language].test(behindFigure.trimStart())) {
+  if (namesALengthOfTime(behindFigure.trimStart())) {
     return "duration";
   }
   return false;
@@ -2839,19 +3579,20 @@ function takeEquivalents(text2, language) {
   if (slashed) {
     rest = slashed.rest;
   }
-  let item = stripItemLead(rest, language);
+  const lead = stripItemLead(rest, language);
+  let item = lead.item;
   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);
-  return { rest, item, bracketed, slashed, trailing, group };
+  return { rest, item, partitive: lead.partitive, bracketed, slashed, trailing, group };
 }
 function whatTheFiguresSize(leading, item, language) {
-  if (language === "fr" && !leading.unit && statesItemSize(item)) {
+  if (usesPartitiveDe(language) && !leading.unit && statesItemSize(item, language)) {
     return "itemSize";
   }
-  if (language === "fr" && leading.partitive && isStatedSize(item)) {
+  if (usesPartitiveDe(language) && leading.partitive && isStatedSize(item, language)) {
     return "itemSize";
   }
   if (leading.unit?.kind === "measured" && CONTAINER_NOUN.test(normalizeUnitKey(item))) {
@@ -2862,7 +3603,7 @@ function whatTheFiguresSize(leading, item, language) {
 function whatTheCountIsOf(behindFigure, language) {
   let rest = behindFigure.trimStart();
   if (language === "en") {
-    rest = rest.replace(LEADING_ARTICLE, "");
+    rest = rest.replace(LEADING_ARTICLE2, "");
   }
   const multiplier = readCountMultiplier(rest);
   if (multiplier) {
@@ -2893,6 +3634,8 @@ function parseIngredient(line, choice = "auto") {
     decoration,
     approximation: null,
     measureAdjective: null,
+    measureAdjectiveFollows: false,
+    itemPartitive: false,
     amount: null,
     amountMax: null,
     rangeSeparator: null,
@@ -2916,11 +3659,7 @@ function parseIngredient(line, choice = "auto") {
   if (!quantity) {
     return empty(null);
   }
-  const notAnAmount = whatTheFigureIsNot(
-    stated.slice(quantity.length),
-    quantity !== article,
-    language
-  );
+  const notAnAmount = whatTheFigureIsNot(stated.slice(quantity.length), quantity !== article);
   if (notAnAmount !== false) {
     return empty(notAnAmount);
   }
@@ -2950,10 +3689,12 @@ function parseIngredient(line, choice = "auto") {
   return {
     original,
     language,
-    heldBack: PER_PERSON[language].test(text2) ? "perPerson" : null,
+    heldBack: statesAnAmountPerEater(text2) ? "perPerson" : null,
     decoration,
     approximation: loose ? loose[0] : null,
     measureAdjective: behind?.unit ? described.adjective : null,
+    measureAdjectiveFollows: measure.follows,
+    itemPartitive: equivalents.partitive,
     amount: whole * times,
     amountMax: range === null ? null : range.max * times,
     rangeSeparator: range?.separator ?? null,
@@ -2969,7 +3710,9 @@ function parseIngredient(line, choice = "auto") {
 }
 function unreadableComma(text2, language, evidence) {
   if (COMMA_GROUPED.test(text2)) {
-    const settled = evidence.french !== evidence.english;
+    const scores = [evidence.french, evidence.english, evidence.spanish];
+    const top = Math.max(...scores);
+    const settled = scores.filter((score) => score === top).length === 1;
     return !settled;
   }
   if (language === "en") {
@@ -2979,8 +3722,8 @@ 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 = OPENING_ARTICLE_FRENCH.exec(text2);
+  if (usesPartitiveDe(language)) {
+    const match = OPENING_ARTICLE_ROMANCE[language].exec(text2);
     if (!match) {
       return null;
     }
@@ -2988,7 +3731,7 @@ function readArticle(text2, language) {
       return null;
     }
     const [word = ""] = match.slice(1);
-    const amount = FRENCH_ARTICLES[word.toLowerCase()];
+    const amount = ROMANCE_ARTICLES[word.toLowerCase()];
     if (amount === void 0) {
       return null;
     }
@@ -3026,8 +3769,8 @@ function takeLeadingUnit(text2, language, fromArticle) {
   if (taken.unit) {
     return { ...taken, partitive: false };
   }
-  if (language === "fr" && fromArticle) {
-    const measure = readPartitiveMeasure(text2);
+  if (usesPartitiveDe(language) && fromArticle) {
+    const measure = readPartitiveMeasure(text2, language);
     if (measure) {
       return { unit: measure.unit, rest: measure.rest, partitive: true };
     }
@@ -3035,10 +3778,17 @@ function takeLeadingUnit(text2, language, fromArticle) {
   return { ...taken, partitive: false };
 }
 function stripItemLead(text2, language) {
-  if (language === "fr") {
-    return text2.replace(LEADING_PARTITIVE, "").replace(LEADING_ARTICLE_FRENCH, "").trim();
+  if (usesPartitiveDe(language)) {
+    const partitive = LEADING_PARTITIVE.test(text2);
+    return {
+      item: text2.replace(LEADING_PARTITIVE, "").replace(ROMANCE_ARTICLE[language], "").trim(),
+      partitive
+    };
   }
-  return text2.replace(OF_OPENING, "").replace(LEADING_INDEFINITE_WITH_SPACE, "").trim();
+  return {
+    item: text2.replace(OF_OPENING, "").replace(LEADING_INDEFINITE_WITH_SPACE, "").trim(),
+    partitive: false
+  };
 }
 function takeAlternates(text2, language) {
   const none = { measures: [], intro: null, published: "", rest: text2 };
@@ -3058,7 +3808,7 @@ function takeAlternates(text2, language) {
 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);
+  const direct = takeUnitAnyLanguage(text2, language);
   if (direct.unit) {
     return direct;
   }
@@ -3066,7 +3816,7 @@ function takeMeasureAfterQuantity(text2, language) {
   if (!partitive) {
     return direct;
   }
-  return takeUnitEitherLanguage(text2.slice(partitive[0].length), language);
+  return takeUnitAnyLanguage(text2.slice(partitive[0].length), language);
 }
 function readBracket(bracket, language) {
   const inside = bracket.slice(1, -1);
@@ -3121,7 +3871,7 @@ function takeSlashAlternates(text2, language) {
     if (!quantity) {
       break;
     }
-    const taken = takeUnitEitherLanguage(after.slice(quantity.length).trimStart(), language);
+    const taken = takeUnitAnyLanguage(after.slice(quantity.length).trimStart(), language);
     if (!taken.unit) {
       break;
     }
@@ -3139,7 +3889,7 @@ function formatAmount(amount, language, options = {}) {
   const decimal = (value) => {
     const rounded = value !== 0 && Math.abs(value) < 0.01 ? Number(value.toPrecision(2)) : Math.round(value * 100) / 100;
     const rendered = String(rounded);
-    return language === "fr" ? rendered.replace(".", ",") : rendered;
+    return writesDecimalComma(language) ? rendered.replace(".", ",") : rendered;
   };
   if (!Number.isFinite(amount)) {
     return "";
@@ -3182,6 +3932,7 @@ var GARLIC = /\bgarlic\b/i;
 var IES_ENDING = /ies$/i;
 var LETTER = new RegExp("\\p{L}", "u");
 var LETTERS_ONLY = /^[A-Za-z]+$/;
+var WORD_LETTERS = new RegExp("^\\p{L}+$", "u");
 var OF_JOINER = / of /i;
 var PLURAL_ENDING = /s$|eaux$|aux$/i;
 var SIBILANT_ENDING = /(?:ch|sh|s|x|z)$/i;
@@ -3190,6 +3941,19 @@ var SIBILANT_PLURAL = /(?:ch|sh|s|x|z)es$/i;
 var TRAILING_S_ANY_CASE2 = /s$/i;
 var VOWEL_OPENING = /^[aeiouàâäéèêëîïôöûü]/i;
 var X_ENDING = /x$/i;
+function equipmentIngredient(line, language = "auto") {
+  return {
+    text: line.trim(),
+    original: line,
+    scaling: "unscaled",
+    amount: null,
+    amountMax: null,
+    unit: null,
+    language: language === "auto" ? detectLanguage(line) : language,
+    isEquipment: true,
+    note: EQUIPMENT_NOTE
+  };
+}
 function roundTo(value, step) {
   return Math.round(Math.round(value / step) * step * 100) / 100;
 }
@@ -3352,11 +4116,11 @@ var PORTION_SIZED_ITEM = new RegExp(
   "iu"
 );
 var QUARTERED_ITEM = new RegExp(
-  "\\b(?:onions?|shallots?|potatoes|potato|carrots?|apples?|pears?|lemons?|limes?|oranges?|tomato(?:es)?|cucumbers?|courgettes?|zucchinis?|aubergines?|eggplants?|squash(?:es)?|pumpkins?|cabbages?|melons?|watermelons?|peppers?|beets?|turnips?|parsnips?|leeks?|bananas?|mango(?:e?s)?|avocados?|legs? of lamb|lamb legs?|baguettes?|camemberts?|cheeses?|chorizos?|pineapples?|peach(?:es)?|apricots?|milk|chickens?|guinea fowls?|roasts?|oignons?|\xE9chalotes?|echalotes?|pommes? de terre|carottes?|pommes?|poires?|citrons?|tomates?|concombres?|courgettes?|aubergines?|potirons?|choux?|chou|melons?|poivrons?|betteraves?|navets?|panais|poireaux?|bananes?|mangues?|avocats?|past\xE8ques?|pasteques?|gigots?|fromages?|ch\xE8vres?|chevres?|ananas|p\xEAches?|peches?|abricots?|laits?|poulets?|pintades?|reblochons?|b\xFBches?|buches?|r\xF4tis?|rotis?)\\b",
+  "\\b(?:onions?|shallots?|potatoes|potato|carrots?|apples?|pears?|lemons?|limes?|oranges?|tomato(?:es)?|cucumbers?|courgettes?|zucchinis?|aubergines?|eggplants?|squash(?:es)?|pumpkins?|cabbages?|melons?|watermelons?|peppers?|beets?|turnips?|parsnips?|leeks?|bananas?|mango(?:e?s)?|avocados?|legs? of lamb|lamb legs?|baguettes?|camemberts?|cheeses?|chorizos?|pineapples?|peach(?:es)?|apricots?|milk|chickens?|guinea fowls?|roasts?|oignons?|\xE9chalotes?|echalotes?|pommes? de terre|carottes?|pommes?|poires?|citrons?|tomates?|concombres?|courgettes?|aubergines?|potirons?|choux?|chou|melons?|poivrons?|betteraves?|navets?|panais|poireaux?|bananes?|mangues?|avocats?|past\xE8ques?|pasteques?|gigots?|fromages?|ch\xE8vres?|chevres?|ananas|p\xEAches?|peches?|abricots?|laits?|poulets?|pintades?|reblochons?|b\xFBches?|buches?|r\xF4tis?|rotis?|cebollas?|cebolletas?|chalotas?|patatas?|papas?|zanahorias?|manzanas?|peras?|limones|lim\xF3n|limon|limas?|naranjas?|tomates?|pepinos?|calabacines|calabac\xEDn|calabacin|berenjenas?|calabazas?|coles|col|melones|mel\xF3n|melon|sand\xEDas?|sandias?|pimientos?|remolachas?|nabos?|chiriv\xEDas?|chirivias?|puerros?|pl\xE1tanos?|platanos?|mangos?|aguacates?|pi\xF1as?|pinas?|melocotones|melocot\xF3n|melocoton|albaricoques?|duraznos?|quesos?|pollos?|asados?|barras? de pan)\\b",
   "iu"
 );
 var HALVED_ITEM = /\b(?:jus|juices?)\b/iu;
-var WHOLE_ITEM = /\b(?:eggs?|yolks?|egg\s+whites?|oeufs?|œufs?|jaunes?\s+d['e]|clous?|zestes?|zests?)\b/iu;
+var WHOLE_ITEM = /\b(?:eggs?|yolks?|egg\s+whites?|oeufs?|œufs?|jaunes?\s+d['e]|clous?|zestes?|zests?|huevos?|yemas?\s+de|claras?\s+de|clavos?\s+de)\b/iu;
 var HALVED_CUT = /\b(?:breasts?|thighs?|drumsticks?|wings?|cutlets?|cuisses?|ailes?|pilons?|escalopes?|magrets?)\b/iu;
 function cloveDivisibility(unit, item) {
   const counted = unit ? unit.canonical === "clove" : CLOVE.test(item);
@@ -3720,6 +4484,9 @@ function agreeLeadingAdjective(word, amount, language) {
   if (language === "en") {
     return word;
   }
+  if (language === "es") {
+    return agreeSpanishAdjective(word, amount);
+  }
   const wantsPlural = amount >= 2;
   const folded = foldWord2(word);
   const isPlural = folded.endsWith("s") && !AGREEABLE_ADJECTIVES.has(folded);
@@ -3733,12 +4500,57 @@ function agreeLeadingAdjective(word, amount, language) {
   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);
   }
+  return language === "es" ? agreeInSpanish(item, amount) : agreeInEnglish(item, amount);
+}
+function agreeInSpanish(item, amount) {
+  if (!item) {
+    return item;
+  }
+  const words = item.split(" ");
+  const head = words[0] ?? "";
+  if (head.length <= 2 || !WORD_LETTERS.test(head)) {
+    return item;
+  }
+  const wantsPlural = amount > 1;
+  const singular = spanishSingular(head);
+  const isPlural = head.toLowerCase() !== singular.toLowerCase();
+  if (wantsPlural === isPlural) {
+    return item;
+  }
+  words[0] = wantsPlural ? spanishPlural(head) : singular;
+  for (let index = 1; index < words.length; index += 1) {
+    const word = words[index] ?? "";
+    if (!WORD_LETTERS.test(word) || SPANISH_PARTITIVE.test(word)) {
+      break;
+    }
+    const adjectiveSingular = spanishSingular(word);
+    const adjectiveIsPlural = word.toLowerCase() !== adjectiveSingular.toLowerCase();
+    if (wantsPlural !== adjectiveIsPlural) {
+      words[index] = wantsPlural ? spanishPlural(word) : adjectiveSingular;
+    }
+  }
+  return words.join(" ");
+}
+var SPANISH_PARTITIVE = /^(?:de|del|con|sin|para|al|y|en|o)$/i;
+function agreeSpanishAdjective(word, amount) {
+  if (!WORD_LETTERS.test(word)) {
+    return word;
+  }
+  const wantsPlural = amount > 1;
+  const singular = spanishSingular(word);
+  const isPlural = word.toLowerCase() !== singular.toLowerCase();
+  if (wantsPlural === isPlural) {
+    return word;
+  }
+  return wantsPlural ? spanishPlural(word) : singular;
+}
+function agreeCountedContainer(item, amount, language) {
+  if (language !== "en") {
+    return agreeWithAmount(item, amount, language);
+  }
   const space = item.indexOf(" ");
   if (space < 0) {
     return agreeInEnglish(item, amount);
@@ -3746,19 +4558,23 @@ function agreeCountedContainer(item, amount, language) {
   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) {
+function joinItem(item, language, partitive) {
   if (!item) {
     return "";
   }
-  if (language === "en") {
+  if (language === "en" || !partitive) {
     return ` ${item}`;
   }
+  if (language === "es") {
+    return ` de ${item}`;
+  }
   const elides = VOWEL_OPENING.test(item) || MUTE_H_WORDS.test(item);
   return elides ? ` d'${item}` : ` de ${item}`;
 }
 var BRANCH_SEPARATORS = {
   en: /\s+or\s+/gi,
-  fr: /\s+ou\s+/gi
+  fr: /\s+ou\s+/gi,
+  es: /\s+o\s+/gi
 };
 function splitBranch(text2, parsed) {
   const itemStart = parsed.item ? text2.indexOf(parsed.item) : text2.length;
@@ -3781,6 +4597,9 @@ function splitBranch(text2, parsed) {
 }
 function scaleIngredient(line, options) {
   const { factor } = options;
+  if (isEquipmentLine(line)) {
+    return equipmentIngredient(line, options.language);
+  }
   if (factor === 1) {
     return passthroughIngredient(line, options.language);
   }
@@ -3832,9 +4651,9 @@ function alternateLabel(count2, style, texts, bracketed) {
   }
   return bracketed;
 }
-function itemLabelFor(named, item, counted, language) {
+function itemLabelFor(named, item, counted, language, partitive) {
   if (named) {
-    return joinItem(item, language);
+    return joinItem(item, language, partitive);
   }
   if (counted) {
     return ` ${counted}`;
@@ -3917,7 +4736,8 @@ function noteForScaledLine(outcome) {
 function renderScaledLine(parsed, alternates, unit, shown, language) {
   const named = unit && !countsBarePieces(unit) ? unit : null;
   const adjective = named && parsed.measureAdjective ? ` ${agreeLeadingAdjective(parsed.measureAdjective, shown, language)}` : "";
-  const unitLabel = named ? `${adjective} ${formatUnit(named, shown, language)}` : "";
+  const measure = named ? ` ${formatUnit(named, shown, language)}` : "";
+  const unitLabel = parsed.measureAdjectiveFollows ? `${measure}${adjective}` : `${adjective}${measure}`;
   const alternateTexts = alternates.map((entry) => entry.text);
   const introduced = parsed.alternateIntro ? `${parsed.alternateIntro} ` : "";
   const bracketed = alternates.length === 0 ? "" : ` (${introduced}${alternateTexts.join(" / ")})`;
@@ -3930,7 +4750,7 @@ function renderScaledLine(parsed, alternates, unit, shown, language) {
   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 = itemLabelFor(named, parsed.item, counted, language);
+  const itemLabel = itemLabelFor(named, parsed.item, counted, language, parsed.itemPartitive);
   return { named, unitLabel, capacityLabel, altLabel, trailingLabel, itemLabel };
 }
 var HELD_BACK_NOTE = {
@@ -3954,6 +4774,7 @@ function scaleSingleLine(line, options) {
       amountMax: null,
       unit: null,
       language,
+      isEquipment: false,
       note: parsed.heldBack ? HELD_BACK_NOTE[parsed.heldBack] : "No quantity given; adjust to taste."
     };
   }
@@ -3993,7 +4814,8 @@ function scaleSingleLine(line, options) {
     amount: low.amount,
     amountMax: collapsed ? null : high?.amount ?? null,
     unit: named?.canonical ?? null,
-    language
+    language,
+    isEquipment: false
   };
   const note = noteForScaledLine({
     parsed,
@@ -4050,6 +4872,9 @@ function scaleIngredients(lines, options) {
   return lines.map((line) => scaleIngredient(line, options));
 }
 function passthroughIngredient(line, language = "auto") {
+  if (isEquipmentLine(line)) {
+    return equipmentIngredient(line, language);
+  }
   const parsed = parseIngredient(line, language);
   const held = parsed.amount === null || parsed.heldBack !== null;
   const result = {
@@ -4059,7 +4884,8 @@ function passthroughIngredient(line, language = "auto") {
     amount: held ? null : parsed.amount,
     amountMax: held ? null : parsed.amountMax,
     unit: held ? null : parsed.unit?.canonical ?? null,
-    language: parsed.language
+    language: parsed.language,
+    isEquipment: false
   };
   if (parsed.heldBack) {
     result.note = HELD_BACK_NOTE[parsed.heldBack];
@@ -4112,6 +4938,9 @@ var reportSchema = z.object({
   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."
   ),
+  names_the_dish: z.number().int().describe(
+    "How many of this source's rows in this answer carry the dish in their title, out of 'count'. A row is what the source returned for the words it was handed, and one of these indexes answers any wording with something, so zero means the source offered rows and none of them is the dish."
+  ),
   wordings: z.array(
     z.object({
       query: z.string().describe("What was sent to this source, or would have been."),
@@ -4141,12 +4970,15 @@ var ingredientSchema = z.object({
   text: z.string().describe("The line as it now reads."),
   original: z.string().describe("The line as published."),
   scaling: z.enum(["scaled", "rounded", "unscaled"]).describe(
-    "'scaled' means the arithmetic landed on the exact product, 'rounded' that something had to move for the line to stay usable or that the line carries a second quantity whose match is the page's claim, 'unscaled' that there is nothing to multiply."
+    "'scaled' means the arithmetic landed on the exact product, 'rounded' that something had to move for the line to stay usable or that the line carries a second quantity whose match is the page's claim, 'unscaled' that the line was left as given. Read 'is_equipment' beside it: a tool line is 'unscaled' whether or not it carries a figure."
   ),
   amount: z.number().nullable().describe("The scaled quantity, in 'unit'. Read the two together, never the number alone."),
   amount_max: z.number().nullable().describe("Upper bound when the line gives a range."),
   unit: z.string().nullable().describe("The unit 'amount' is in, which may differ from the page's."),
-  language: z.enum(["fr", "en"]).describe("The language the line was read and rewritten in."),
+  language: z.enum(["fr", "en", "es"]).describe("The language the line was read and rewritten in."),
+  is_equipment: z.boolean().describe(
+    "True for a line naming a tool, which some sites write among the ingredients. Such a line is never multiplied: a recipe made for more people uses the same pan."
+  ),
   note: z.string().optional().describe("What happened to this line, when anything did.")
 });
 function toIngredientPayload(entry) {
@@ -4158,6 +4990,7 @@ function toIngredientPayload(entry) {
     amount_max: entry.amountMax,
     unit: entry.unit,
     language: entry.language,
+    is_equipment: entry.isEquipment,
     ...entry.note ? { note: entry.note } : {}
   };
 }
@@ -4186,6 +5019,7 @@ function toReportPayload(report) {
     skipped: report.skipped,
     cached: report.cached,
     preferred_by_name: report.preferredByName,
+    names_the_dish: report.namesTheDish,
     wordings: report.wordings.map((attempt) => ({
       query: attempt.query,
       derivation: attempt.derivation,
@@ -4221,6 +5055,47 @@ function labelNote(label, note) {
   const said = note.text;
   return mustKeep(`${label}: ${said}`);
 }
+function answeredNotes(report) {
+  const notes = [];
+  const sent = report.wordings.filter((attempt) => attempt.ran && attempt.error === null);
+  if (report.count === 0) {
+    notes.push(nothingOfferedNote(report, sent));
+  }
+  if (sent.length > 1) {
+    notes.push(
+      `${report.name} was asked ${sent.length} wordings and these rows are their union: ${sent.map((attempt) => `"${quoteForeign(attempt.query)}" (${attempt.count ?? 0})`).join(", ")}. Those counts are per wording and are never added.`
+    );
+  }
+  if (report.skipped > 0) {
+    notes.push(
+      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) {
+    const forWording = sent.length > 1 ? ` That number belongs to "${quoteForeign(sent[0]?.query ?? "")}" alone.` : "";
+    notes.push(
+      `${report.name} reported ${report.reportedTotal}: ${report.reportedTotalMeans}.${forWording}`
+    );
+  } else {
+    notes.push(
+      `${report.name} publishes no count of what a search matched, so a short list here is not evidence that little exists.`
+    );
+  }
+  return notes;
+}
+function listNames(names2) {
+  if (names2.length <= 1) {
+    return names2.join("");
+  }
+  return `${names2.slice(0, -1).join(", ")} and ${names2.at(-1)}`;
+}
+function nothingOfferedNote(report, sent) {
+  return mustKeep(
+    sent.length > 1 ? `${report.name} answered and offered no row for any of the ${sent.length} wordings it was sent (${sent.map((attempt) => `"${quoteForeign(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.`
+  );
+}
 function reportNotes(reports) {
   const notes = [];
   const answered = reports.filter((report) => report.status === "answered");
@@ -4234,51 +5109,34 @@ function reportNotes(reports) {
     );
   }
   for (const report of answered) {
-    const sent = report.wordings.filter((attempt) => attempt.ran && attempt.error === null);
-    if (report.count === 0) {
-      notes.push(
-        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(
-        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) {
-      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.`
-      );
-    }
+    notes.push(...answeredNotes(report));
   }
-  if (answered.some((report) => report.mixesReferencePages && report.count > 0)) {
-    const mixing = answered.filter((report) => report.mixesReferencePages && report.count > 0);
+  const offTopic = answered.filter((report) => report.count > 0 && report.namesTheDish === 0);
+  const onTopic = answered.some((report) => report.namesTheDish > 0);
+  if (offTopic.length > 0 && onTopic) {
     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 what it read off the page.`
+      mustKeep(
+        `No row from ${listNames(offTopic.map((report) => report.name))} carries this dish in its title. Those indexes answer the words they are handed, so rows came back for a dish they may not hold. Ask in the language that source publishes in, or open a row with get_recipe before calling it the dish.`
+      )
     );
   }
+  if (answered.some((report) => report.count > 0)) {
+    notes.push(
+      "Each source's rows are arranged with the ones naming the dish first. That is an order over one source's own rows and not a score against any other source."
+    );
+  }
+  for (const report of answered) {
+    if (report.rowsThatAreNotRecipes !== null && report.count > 0) {
+      notes.push(
+        `A row from ${report.name} can be ${report.rowsThatAreNotRecipes}. get_recipe says what it read off the page.`
+      );
+    }
+  }
   if (answered.length > 1) {
     notes.push(
-      "Each count above measures something different, and they are never added together into one total."
+      mustKeep(
+        "Each count above measures something different, and they are never added together into one total."
+      )
     );
   }
   if (reports.some((report) => report.cached)) {
@@ -4383,7 +5241,7 @@ function creditLine(contributors) {
 }
 
 // src/tools/recipeView.ts
-var SERVING_WORD = /personne|people|serving|portion|part\b/i;
+var SERVING_WORD = /personne|people|serving|portion|part\b|racion|raciones|rac\b|persona|personas|comensal|comensales/i;
 function whatTheOtherPartHolds(part, recipe) {
   if (part === "ingredients") {
     return recipe.steps.length > 0 ? `${recipe.steps.length} step(s) of method were read from it` : null;
@@ -4409,7 +5267,7 @@ var recipeSchema = z2.object({
   id: z2.string(),
   source: z2.string(),
   source_name: z2.string(),
-  language: z2.enum(["fr", "en"]).describe("The language this recipe is written in."),
+  language: z2.enum(["fr", "en", "es"]).describe("The language this recipe is written in."),
   title: z2.string(),
   url: z2.string(),
   image_url: z2.string().nullable(),
@@ -4446,9 +5304,41 @@ var recipeSchema = z2.object({
   scaling_summary: z2.object({
     scaled_count: z2.number().int(),
     rounded_count: z2.number().int(),
-    unscaled_count: z2.number().int()
-  })
+    unscaled_count: z2.number().int(),
+    equipment_count: z2.number().int().describe("Lines naming a tool, which some sites write among the ingredients.")
+  }).describe("The four counts add up to the number of ingredient lines.")
+});
+var collectionSchema = z2.object({
+  id: z2.string(),
+  source: z2.string(),
+  source_name: z2.string(),
+  title: z2.string(),
+  url: z2.string(),
+  image_url: z2.string().nullable(),
+  headings: z2.array(z2.string()).describe(
+    "The headings the article is built from, in the order it prints them, up to 'max_gathered'."
+  ),
+  recipes: z2.array(rowSchema).describe(
+    "The recipes it points at, each readable with get_recipe, up to 'max_gathered'. 'gathered_count' says how many the article holds."
+  ),
+  gathered_count: z2.number().int().describe("Recipes the article points at, whether or not they are all listed here."),
+  attribution: z2.string().describe("Show this, with the url, when repeating anything from here.")
 });
+function buildCollectionView(recipe, limit) {
+  const gathered = recipe.gathers?.rows ?? [];
+  return {
+    id: recipe.id,
+    source: recipe.source,
+    source_name: recipe.sourceName,
+    title: recipe.title,
+    url: recipe.url,
+    image_url: recipe.imageUrl,
+    headings: (recipe.gathers?.headings ?? []).slice(0, limit),
+    recipes: gathered.slice(0, limit).map(toRowPayload),
+    gathered_count: gathered.length,
+    attribution: recipe.attribution
+  };
+}
 var SECTIONS = [
   "ingredients",
   "steps",
@@ -4498,7 +5388,7 @@ function resolveFactor(recipe, servings) {
   const unit = recipe.yieldUnit;
   if (unit && !SERVING_WORD.test(unit)) {
     notes.push(
-      `This page states its yield in ${quoteForeign(unit)} rather than in servings, so asking for ${servings} multiplied the quantities by ${round(factor)} to give ${servings} ${quoteForeign(unit)}.`
+      `This page counts its yield in ${quoteForeign(unit)}, which is not a number of eaters, so asking for ${servings} multiplied the quantities by ${round(factor)} to give ${servings} ${quoteForeign(unit)}.`
     );
   }
   return { factor, notes };
@@ -4555,6 +5445,11 @@ function partNotes(recipe, wants) {
   if (wants("steps") && recipe.steps.length === 0) {
     notes.push(emptyPartNote(recipe, METHOD_PART));
   }
+  if (wants("equipment") && recipe.equipment.length === 0 && recipe.ingredients.length > 0) {
+    notes.push(
+      `${recipe.sourceName} keeps no equipment list of its own. What a recipe is cooked with is written among the ingredients, where each such line carries 'is_equipment'.`
+    );
+  }
   if (wants("steps") && recipe.stepsAsOneBlock === true && recipe.steps.length > 0) {
     notes.push(
       mustKeep(
@@ -4569,8 +5464,11 @@ function buildRecipeView(recipe, options) {
   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, ...partNotes(recipe, wants)];
-  const rounded = ingredients.filter((entry) => entry.scaling === "rounded");
-  const unscaled = ingredients.filter((entry) => entry.scaling === "unscaled");
+  const rounded = ingredients.filter((entry) => entry.scaling === "rounded" && !entry.isEquipment);
+  const equipment = ingredients.filter((entry) => entry.isEquipment);
+  const unscaled = ingredients.filter(
+    (entry) => entry.scaling === "unscaled" && !entry.isEquipment
+  );
   if (rounded.length > 0) {
     notes.push(
       `${rounded.length} line(s) did not land on the exact product; each says in its own note what happened to it.`
@@ -4581,6 +5479,11 @@ function buildRecipeView(recipe, options) {
       `${unscaled.length} line(s) carry no quantity to multiply and are repeated as published.`
     );
   }
+  if (equipment.length > 0) {
+    notes.push(
+      `${equipment.length} line(s) name a tool, which this site writes among them. They were left as published: a recipe made for more people uses the same one.`
+    );
+  }
   if (recipe.license) {
     notes.push(
       mustKeep(
@@ -4636,9 +5539,14 @@ function buildRecipeView(recipe, options) {
     sections_returned: [...options.sections],
     sections_omitted: omitted,
     scaling_summary: {
-      scaled_count: ingredients.filter((entry) => entry.scaling === "scaled").length,
+      // A tool line is counted apart, so the four counts add up to the lines in
+      // the list. It carries "unscaled" like a line with no figure on it, and
+      // merging the two would say this server found no quantity where it found
+      // one and declined it.
+      scaled_count: ingredients.filter((entry) => entry.scaling === "scaled" && !entry.isEquipment).length,
       rounded_count: rounded.length,
-      unscaled_count: unscaled.length
+      unscaled_count: unscaled.length,
+      equipment_count: equipment.length
     }
   };
   if (options.label) {
@@ -4769,12 +5677,6 @@ var compareRecipesOutput = z4.object({
 });
 var TEXT_INGREDIENT_LINES = 8;
 var TEXT_DIFFERENCE_LINES = 4;
-function listNames(names2) {
-  if (names2.length <= 1) {
-    return names2.join("");
-  }
-  return `${names2.slice(0, -1).join(", ")} and ${names2.at(-1)}`;
-}
 function agrees(names2, singular, plural) {
   return names2.length === 1 ? singular : plural;
 }
@@ -4823,12 +5725,11 @@ function describeDifferences(recipes, payloads, sections) {
       `${stated.map((one) => `${one.name} yields ${quoteForeign(one.text)}`).join("; ")}.`
     );
   }
-  const counts = payloads.map((payload) => payload.ingredients.length);
+  const foodLines = (payload) => payload.ingredients.filter((entry) => !entry.is_equipment).length;
+  const counts = payloads.map(foodLines);
   if (new Set(counts).size > 1 && counts.every((value) => value > 0)) {
     differences.push(
-      `${payloads.map(
-        (payload) => `${payload.source_name} lists ${payload.ingredients.length} ingredient lines`
-      ).join("; ")}.`
+      `${payloads.map((payload) => `${payload.source_name} lists ${foodLines(payload)} ingredient lines`).join("; ")}.`
     );
   }
   if (sections.includes("times")) {
@@ -4874,6 +5775,30 @@ function describeDifferences(recipes, payloads, sections) {
   }
   return differences;
 }
+function whyItIsMissing(report, dish, outcome) {
+  if (outcome.article) {
+    return mustKeep(
+      `${report.name} is missing from this comparison because the page its search offered gathers other recipes: ${quoteForeign(outcome.article.title)}, ${quoteForeign(outcome.article.url)}. Read one of the recipes it lists with get_recipe.`
+    );
+  }
+  if (report.status === "failed") {
+    return 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.`
+    );
+  }
+  if (outcome.failedRead) {
+    return mustKeep(
+      `${report.name}'s search answered and offered a version, and that version could not be read (${quoteForeign(
+        `${outcome.failedRead.code}: ${outcome.failedRead.message}`
+      )}). The failure is in the reading, so nothing here says whether ${report.name} holds this dish.`
+    );
+  }
+  return mustKeep(
+    `${report.name} answered and offered nothing close enough to "${quoteForeign(dish)}" to compare.`
+  );
+}
 async function runCompareRecipes(client, args) {
   try {
     const merged = await client.searchRecipes(
@@ -4891,6 +5816,7 @@ async function runCompareRecipes(client, args) {
     const reads = await Promise.allSettled(offered.map(([, id]) => client.getRecipe(id)));
     const recipes = [];
     const unread = /* @__PURE__ */ new Map();
+    const gathered = /* @__PURE__ */ new Map();
     const opened = /* @__PURE__ */ new Set();
     reads.forEach((read, index) => {
       const source = offered[index]?.[0];
@@ -4899,6 +5825,10 @@ async function runCompareRecipes(client, args) {
       }
       opened.add(source);
       if (read.status === "fulfilled") {
+        if (read.value.recipe.gathers) {
+          gathered.set(source, read.value.recipe);
+          return;
+        }
         recipes.push(read.value.recipe);
         return;
       }
@@ -4935,30 +5865,12 @@ async function runCompareRecipes(client, args) {
       if (recipes.some((recipe) => recipe.source === report.source)) {
         continue;
       }
-      const failedRead = unread.get(report.source);
-      if (report.status === "failed") {
-        notes.push(
-          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(
-          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(
-          mustKeep(
-            `${report.name} answered and offered nothing close enough to "${quoteForeign(args.dish)}" to compare.`
-          )
-        );
-      }
+      notes.push(
+        whyItIsMissing(report, args.dish, {
+          article: gathered.get(report.source),
+          failedRead: unread.get(report.source)
+        })
+      );
     }
     const weighed = weighTitlesAgainstTheDish(payloads, args.dish, notes);
     const comparable = recipes.filter(
@@ -5047,42 +5959,60 @@ 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.",
+  "Read 'kind' first. Some sources publish articles gathering other recipes at the same kind of address as a recipe, and such an answer carries 'collection' with the recipes it points at and no 'recipe' at all: there is nothing to cook from that page, and the recipes it lists are read with get_recipe.",
   "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(" ");
+var LISTING_SHARE = 2 / 3;
 var getRecipeInput = strictInput({
   id: z5.string().min(1).max(500).describe(
-    "From search_recipes, such as 'marmiton:44078', 'goodfood:recipes/carbonara' or 'cookbook:Cookbook:Carbonara'. Two sources address a recipe by a bare number, so spell an id with its source."
+    "From search_recipes, such as 'marmiton:44078', 'pequerecetas:paella-de-marisco' or 'cookbook:Cookbook:Carbonara'. Two sources address a recipe by a bare number, so spell an id with its source."
   ),
   servings: z5.number().int().min(1).max(500).optional().describe("Rescale to this many. Left out, the quantities come back as published."),
   sections: z5.array(z5.enum(SECTIONS)).default(["ingredients", "steps"]).describe("Which parts to return. A full recipe is a lot of text, so this defaults to two."),
   max_steps: z5.number().int().min(1).max(100).default(20).describe("Steps to return. The answer says how many more there are."),
+  max_gathered: z5.number().int().min(1).max(500).default(30).describe(
+    "Recipes and headings to return from an address that gathers recipes. The answer says how many the article holds."
+  ),
   max_step_chars: z5.number().int().min(80).max(4e3).default(600).describe("Characters kept per step. Raise it only if a step was cut mid-sentence.")
 });
 var getRecipeOutput = z5.object({
-  recipe: recipeSchema,
+  kind: z5.enum(["recipe", "collection"]).describe(
+    "What the address held. 'recipe' comes with 'recipe' and no 'collection'; 'collection' comes with 'collection' and no 'recipe', and is an article gathering other recipes, with no ingredients and no method of its own."
+  ),
+  recipe: recipeSchema.optional().describe("Present when 'kind' is 'recipe'."),
+  collection: collectionSchema.optional().describe("Present when 'kind' is 'collection'."),
   id_read_as: z5.string().nullable().describe("How a raw identifier was routed, when it was not spelled with its source."),
   notes: z5.array(z5.string())
 });
+var ARGUMENTS_FOR_A_RECIPE = ["servings"];
 async function runGetRecipe(client, args) {
   try {
     const { recipe, cached, read } = await client.getRecipe(args.id);
+    const routed = read.inferred ? [
+      `"${quoteForeign(args.id)}" was read as ${read.source.name}'s, because ${read.inferred}. Spell an id with its source to leave nothing to infer.`
+    ] : [];
+    const served = cached ? ["Served from this server's short-lived in-memory cache."] : [];
+    if (recipe.gathers) {
+      const ignored = ARGUMENTS_FOR_A_RECIPE.filter((name) => args[name] !== void 0);
+      const said = ignored.length > 0 ? [
+        `This address held an article, so ${ignored.map((name) => `'${name}'`).join(" and ")} had nothing to act on. Call get_recipe on one of the recipes it lists.`
+      ] : [];
+      return gatheredAnswer(
+        recipe,
+        read.inferred,
+        [...routed, ...served, ...said],
+        args.max_gathered
+      );
+    }
     const view = buildRecipeView(recipe, {
       servings: args.servings ?? null,
       sections: args.sections,
       maxSteps: args.max_steps,
       maxStepChars: args.max_step_chars
     });
-    const notes = [...view.notes];
-    if (read.inferred) {
-      notes.unshift(
-        `"${quoteForeign(args.id)}" was read as ${read.source.name}'s, because ${read.inferred}. Spell an id with its source to leave nothing to infer.`
-      );
-    }
-    if (cached) {
-      notes.push("Served from this server's short-lived in-memory cache.");
-    }
+    const notes = [...routed, ...view.notes, ...served];
     const payload = view.payload;
     const credit = creditLine([{ attribution: payload.attribution, url: payload.url }]);
     const head = [
@@ -5090,9 +6020,12 @@ async function runGetRecipe(client, args) {
       quoteForeign(payload.url),
       renderYield(payload)
     ];
-    const ingredientLines = payload.ingredients.map(
-      (entry) => entry.scaling === "unscaled" ? `- ${quoteForeign(entry.text)} (no quantity)` : `- ${quoteForeign(entry.text)}`
-    );
+    const ingredientLines = payload.ingredients.map((entry) => {
+      if (entry.is_equipment) {
+        return `- ${quoteForeign(entry.text)} (a tool)`;
+      }
+      return 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);
@@ -5115,7 +6048,7 @@ async function runGetRecipe(client, args) {
       }
     }
     return ok(
-      { recipe: payload, id_read_as: read.inferred, notes: noteTexts(notes) },
+      { kind: "recipe", recipe: payload, id_read_as: read.inferred, notes: noteTexts(notes) },
       lines.join("\n"),
       { notes, credit }
     );
@@ -5123,11 +6056,54 @@ async function runGetRecipe(client, args) {
     return toToolError(error);
   }
 }
+function gatheredAnswer(recipe, inferred, earlier, limit) {
+  const payload = buildCollectionView(recipe, limit);
+  const notes = [
+    ...earlier,
+    ...payload.gathered_count > payload.recipes.length ? [
+      `This article points at ${payload.gathered_count} recipes and ${payload.recipes.length} are here. Raise 'max_gathered' for the rest.`
+    ] : [],
+    mustKeep(
+      `This address gathers other recipes, so there are no ingredients and no method to read. ${payload.source_name} publishes both at this kind of address. Call get_recipe on one of the recipes listed here.`
+    )
+  ];
+  const credit = creditLine([{ attribution: payload.attribution, url: payload.url }]);
+  const head = [
+    `${quoteForeign(payload.title)} \xB7 ${quoteForeign(payload.source_name)}`,
+    quoteForeign(payload.url),
+    `An article that gathers ${payload.gathered_count} recipe(s).`
+  ];
+  const rows = payload.recipes.map(
+    (row) => `- ${quoteForeign(row.title)} (${quoteForeign(row.id)})`
+  );
+  const headings = payload.headings.map(quoteForeign);
+  const room = roomForBody({ notes, credit }) - head.join("\n").length;
+  const fitted = fitLines(rows, room * LISTING_SHARE);
+  const shownHeadings = fitLines(headings, room - fitted.lines.join("\n").length);
+  const lines = [...head];
+  if (rows.length > 0) {
+    lines.push("", "Recipes it points at:", ...fitted.lines);
+    if (fitted.hidden > 0) {
+      lines.push(omittedLinesLine(fitted.lines.length, rows.length, "recipes"));
+    }
+  }
+  if (headings.length > 0 && shownHeadings.lines.length > 0) {
+    lines.push("", `Built from: ${shownHeadings.lines.join(", ")}`);
+    if (shownHeadings.hidden > 0) {
+      lines.push(omittedLinesLine(shownHeadings.lines.length, headings.length, "headings"));
+    }
+  }
+  return ok(
+    { kind: "collection", collection: payload, id_read_as: inferred, notes: noteTexts(notes) },
+    lines.join("\n"),
+    { notes, credit }
+  );
+}
 
 // src/tools/scaleIngredients.ts
 import { z as z6 } from "zod";
 var scaleIngredientsDescription = [
-  "Multiply a list of ingredient lines, in French, in English, or in a list holding both.",
+  "Multiply a list of ingredient lines, in French, in English, in Spanish, or in a list holding more than one of them.",
   "Give either 'factor', or 'from_servings' and 'to_servings' and the factor is worked out from them.",
   "Quantities land where a kitchen can follow them: an egg stays whole because half of one is not something a cook takes out of the shell, while anything that pours, weighs or cuts can halve, a spoonful shrinks into the smaller spoon before it is rounded, and a pinch keeps whatever size a hand gives it while its count is multiplied.",
   "Every line comes back with 'scaling': 'scaled' when the arithmetic landed on the exact product, 'rounded' when something had to move for the line to stay usable, 'unscaled' when the line carries nothing to multiply. A rounded line says what it was rounded from and in which direction.",
@@ -5142,8 +6118,8 @@ var scaleIngredientsInput = strictInput({
   ),
   from_servings: z6.number().int().min(1).max(500).optional().describe("What the list serves now. Give it with 'to_servings', and without 'factor'."),
   to_servings: z6.number().int().min(1).max(500).optional().describe("What it should serve. Give it with 'from_servings', and without 'factor'."),
-  language: z6.enum(["auto", "fr", "en"]).default("auto").describe(
-    "'auto' reads each line on its own, which is what a list holding both languages needs. Name a language to read every line that way."
+  language: z6.enum(["auto", "fr", "en", "es"]).default("auto").describe(
+    "'auto' reads each line on its own, which is what a list holding more than one language needs. Name a language to read every line that way."
   )
 });
 var scaleIngredientsOutput = z6.object({
@@ -5152,7 +6128,10 @@ var scaleIngredientsOutput = z6.object({
   ingredients: z6.array(ingredientSchema),
   scaled_count: z6.number().int().describe("Lines whose arithmetic came out exact."),
   rounded_count: z6.number().int().describe("Lines whose value moved to stay usable."),
-  unscaled_count: z6.number().int().describe("Lines carrying nothing that can be multiplied."),
+  unscaled_count: z6.number().int().describe("Lines carrying nothing that can be multiplied, tools excepted."),
+  equipment_count: z6.number().int().describe(
+    "Lines naming a tool, which are never multiplied: a recipe made for more people uses the same pan."
+  ),
   notes: z6.array(z6.string())
 });
 function resolveFactor2(args) {
@@ -5195,7 +6174,8 @@ function runScaleIngredients(args) {
     const counts = {
       scaled_count: scaled.filter((entry) => entry.scaling === "scaled").length,
       rounded_count: scaled.filter((entry) => entry.scaling === "rounded").length,
-      unscaled_count: scaled.filter((entry) => entry.scaling === "unscaled").length
+      unscaled_count: scaled.filter((entry) => entry.scaling === "unscaled" && !entry.isEquipment).length,
+      equipment_count: scaled.filter((entry) => entry.isEquipment).length
     };
     const notes = [];
     if (counts.rounded_count > 0) {
@@ -5208,11 +6188,16 @@ function runScaleIngredients(args) {
         `${counts.unscaled_count} line(s) carry no quantity to multiply and are repeated as given.`
       );
     }
+    if (counts.equipment_count > 0) {
+      notes.push(
+        `${counts.equipment_count} line(s) name a tool and were left as given: a recipe made for more people uses the same one.`
+      );
+    }
     if (args.language === "auto") {
       const languages = new Set(scaled.map((entry) => entry.language));
       if (languages.size > 1) {
         notes.push(
-          "This list holds lines in both languages, and each was read and rewritten in its own."
+          "This list holds lines in more than one language, and each was read and rewritten in its own."
         );
       }
     }
@@ -5261,7 +6246,7 @@ 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 what it read off the page.",
+  "Not every row opens onto a recipe. Some sources file pages about an ingredient beside the recipes using it, and some publish articles that gather recipes; 'per_source' says in each source's own words what one of its rows can be. Only get_recipe tells 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.",
@@ -5378,7 +6363,8 @@ async function runSearchRecipes(client, args) {
     ];
     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}":
+    const anyNamesTheDish = merged.reports.some((report) => report.namesTheDish > 0);
+    const body = results.length > 0 ? `${results.length} ${anyNamesTheDish ? "recipes" : "rows"} for "${args.query}":
 ${renderRows(results)}${alsoSent}` : nothingCameBack(answered.length, args.query, alsoSent);
     return ok(
       {
@@ -5415,8 +6401,9 @@ function buildInstructions(sources) {
     `Tools for recipes, reading ${sources.length} sources: ${named}. No API key and no account are needed.`,
     "search_recipes asks every source at once and returns one list; every id it hands back names the source it came from, and get_recipe routes on that.",
     "Use compare_recipes when the question is how a dish differs between traditions: it reads each source's closest version and can rescale them all to the same number of servings so the lists stand comparison.",
+    "get_recipe answers in two shapes and says which under 'kind': a recipe, or an article gathering other recipes, which some sources publish at the same kind of address and which carries no ingredients and no method of its own.",
     "Do not rescale quantities yourself. get_recipe and scale_ingredients keep an egg whole, halve what pours or cuts, move a small measurement to a smaller unit before rounding it, and flag what cannot be scaled, which is what stops answers like '2.4 eggs'.",
-    "scale_ingredients works offline on a list from anywhere and reads French and English lines in one call, each in its own language.",
+    "scale_ingredients works offline on a list from anywhere and reads French, English and Spanish lines in one call, each in its own language.",
     "A source that fails is named as a source that failed. An answer holding rows from some sources is never evidence about what the others hold, and 'per_source' says which was which.",
     "The sources share no scale. Their result counts count different things and are never added; some carry reader ratings and some have no author and no rating by nature, so rows are interleaved rather than ranked.",
     "Nothing is converted between measuring systems, and a yield is repeated in the source's own words, because '4 \xE0 6 personnes' and '4 personnes' are different claims. A page stating no yield cannot be rescaled and says so.",
@@ -5457,7 +6444,7 @@ function createServer(options = {}) {
   server.registerTool(
     "scale_ingredients",
     {
-      title: "Scale an ingredient list, in either language",
+      title: "Scale an ingredient list, in any language it reads",
       description: scaleIngredientsDescription,
       inputSchema: scaleIngredientsInput,
       outputSchema: scaleIngredientsOutput,