mcp-recipes 2.0.0 → 3.0.1

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 = "2.0.0";
+var PKG_VERSION = "3.0.1";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -91,6 +91,13 @@ function loadConfig(env = process.env) {
   };
 }
 
+// src/sources/registry.ts
+import { GoodFoodClient } from "mcp-bbc-goodfood/client";
+import { MarmitonClient } from "mcp-marmiton/client";
+import { PtitchefClient } from "mcp-ptitchef/client";
+import { SupertoinetteClient } from "mcp-supertoinette/client";
+import { CookbookClient } from "mcp-wikibooks-cookbook/client";
+
 // src/errors.ts
 var ERROR_CODES = [
   "not_found",
@@ -164,68 +171,6 @@ function fromSource(error, sourceName) {
   }
 }
 
-// src/sources/ids.ts
-var SEPARATOR = ":";
-function resolveId(rawId, sources) {
-  const trimmed = rawId.trim();
-  if (trimmed === "") {
-    throw invalidInput(
-      "A recipe identifier is required.",
-      `Use one of the ids search_recipes returned, such as ${example(sources)}.`
-    );
-  }
-  for (const source of sources) {
-    const prefix = `${source.id}${SEPARATOR}`;
-    if (!trimmed.toLowerCase().startsWith(prefix.toLowerCase())) {
-      continue;
-    }
-    const reference = trimmed.slice(prefix.length).trim();
-    if (reference === "") {
-      throw invalidInput(
-        `"${trimmed}" names a source and no recipe.`,
-        "Put the source's own identifier after the colon."
-      );
-    }
-    return { source, reference, inferred: null };
-  }
-  const claimed = sources.map((source) => ({ source, claim: source.claims(trimmed) })).filter(
-    (entry) => Boolean(entry.claim)
-  );
-  if (claimed.length > 1) {
-    throw invalidInput(
-      `"${trimmed}" could be an identifier on ${names(claimed.map((entry) => entry.source))}, so it names no one recipe.`,
-      `Spell it with its source, as in ${claimed.map((entry) => `${entry.source.id}:${trimmed}`).join(" or ")}.`
-    );
-  }
-  const only = claimed[0];
-  if (!only) {
-    throw invalidInput(
-      `"${trimmed}" is not an identifier any of the sources this server reads would mint.`,
-      `Call search_recipes with "${trimmed}" as the query and pass an id from a row, which reads like ${example(sources)}.`
-    );
-  }
-  return {
-    source: only.source,
-    reference: only.claim.reference,
-    inferred: only.claim.guess ? `${only.claim.why}, which is a guess: check the recipe that comes back is the one you meant` : only.claim.why
-  };
-}
-function names(sources) {
-  const all = sources.map((source) => source.name);
-  if (all.length <= 1) {
-    return all.join("");
-  }
-  return `${all.slice(0, -1).join(", ")} and ${all.at(-1)}`;
-}
-function example(sources) {
-  const first = sources[0];
-  return first ? `${first.id}${SEPARATOR}<the source's own id>` : "<source>:<id>";
-}
-
-// src/sources/registry.ts
-import { MarmitonClient } from "mcp-marmiton/client";
-import { CookbookClient } from "mcp-wikibooks-cookbook/client";
-
 // src/sources/adapter.ts
 var NUMBER_AND_REST = /^\s*(\d+(?:[.,]\d+)?)\s*(.*)$/;
 var RANGE_AND_REST = /^\s*(\d+(?:[.,]\d+)?)\s*(?:à|a|to|-|–|—|ou|or)\s*(\d+(?:[.,]\d+)?)\s*(.*)$/i;
@@ -425,12 +370,176 @@ function cookbookDetail(payload) {
     nutrition: publishedFigures(recipe.nutrition),
     equipment: textList(recipe.equipment),
     tips: textList(recipe.tips),
+    // The Cookbook publishes no resting time, says nothing about how a page
+    // lays its method out, and keeps nothing behind a subscription.
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    withheld: null,
     // A licence is only stated when both halves of it arrived: a name with no
     // address, or an address with no name, is not terms anyone can follow.
     license: licenseTitle && licenseUrl ? { title: licenseTitle, url: licenseUrl } : null
   };
 }
 
+// src/sources/goodfood.ts
+var GOODFOOD_PROFILE = {
+  id: "goodfood",
+  name: "BBC Good Food",
+  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
+};
+var SITE_URL2 = /^https?:\/\/(?:www\.)?bbcgoodfood\.com\//i;
+var REFERENCE = /^recipes\/[^/]+$/;
+var DOT_SEGMENT = /(?:^|\/)\.\.?(?:\/|$)/;
+var LEADING_SLASH = /^\/+/;
+function asReference(raw) {
+  const path = raw.replace(LEADING_SLASH, "");
+  return REFERENCE.test(path) && !DOT_SEGMENT.test(`/${path}`) ? path : null;
+}
+function meansFor(report) {
+  if (count(report.total_available) === null) {
+    return null;
+  }
+  return report.total_is_ceiling === true ? "recipes BBC Good Food says its catalogue matches this wording, cut at the largest number of rows one search will serve, so it states a floor rather than a count" : "recipes BBC Good Food says its whole catalogue matches this wording; it counts the catalogue rather than the rows served";
+}
+function nutritionPanel(recipe) {
+  const facts = Array.isArray(recipe.nutrition) ? recipe.nutrition : [];
+  const kept = {};
+  for (const fact of facts) {
+    const label = text(fact?.label);
+    const value = count(fact?.value);
+    if (label === null || value === null) {
+      continue;
+    }
+    const unit = text(fact?.unit);
+    kept[label] = unit === null ? String(value) : `${value} ${unit}`;
+  }
+  const per = text(recipe.nutrition_per);
+  if (Object.keys(kept).length === 0) {
+    return null;
+  }
+  if (per !== null) {
+    kept.per = per;
+  }
+  return kept;
+}
+function goodfoodAdapter(reader) {
+  return {
+    ...GOODFOOD_PROFILE,
+    claims(raw) {
+      if (SITE_URL2.test(raw)) {
+        const path2 = asReference(new URL(raw).pathname);
+        return path2 === null ? null : { reference: path2, why: "the address is a BBC Good Food recipe page", guess: false };
+      }
+      const path = asReference(raw);
+      return path === null ? null : {
+        reference: path,
+        why: "the path is the shape BBC Good Food mints for a recipe",
+        guess: false
+      };
+    },
+    async search(query, limit) {
+      const outcome = await reader.searchRecipes(query, { limit });
+      const report = outcome.data ?? {};
+      const list = rowsOf(report.results, GOODFOOD_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!(id && title && url)) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(GOODFOOD_PROFILE.id, id),
+          source: GOODFOOD_PROFILE.id,
+          sourceName: GOODFOOD_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.image_url),
+          // A row carries a title and a picture and no prose.
+          excerpt: null
+        });
+      }
+      return {
+        rows,
+        skipped,
+        reportedTotal: count(report.total_available),
+        reportedTotalMeans: meansFor(report),
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: goodfoodDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function goodfoodDetail(payload) {
+  const recipe = payload ?? {};
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const value = count(recipe.rating);
+  const groups = Array.isArray(recipe.ingredients) ? recipe.ingredients : [];
+  const lines = [];
+  for (const group of groups) {
+    const heading = text(group?.heading);
+    if (heading !== null) {
+      lines.push(heading);
+    }
+    for (const entry of group?.ingredients ?? []) {
+      const line = text(entry?.text);
+      if (line !== null) {
+        lines.push(line);
+      }
+    }
+  }
+  return {
+    ...detailBase(GOODFOOD_PROFILE),
+    id: namespacedId(GOODFOOD_PROFILE.id, required(recipe.id, "id", GOODFOOD_PROFILE)),
+    title: required(recipe.title, "title", GOODFOOD_PROFILE),
+    url: required(recipe.url, "url", GOODFOOD_PROFILE),
+    // A row carries the picture; the recipe page's own is not read.
+    imageUrl: null,
+    yieldCount: count(recipe.yield_count) ?? span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit,
+    ingredients: lines,
+    steps: Array.isArray(recipe.steps) ? recipe.steps.filter((step) => typeof step === "string") : [],
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    // The site publishes no resting time of its own.
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    // The page carries these and the site sells access to them. What is said
+    // here is what the site did, so an answer never reports a wall as a page
+    // this server could not read.
+    withheld: recipe.premium === true ? {
+      parts: ["ingredients", "method"],
+      why: "BBC Good Food keeps this recipe's ingredients and method for its subscribers, and publishes its title, its times, its rating and its nutrition"
+    } : null,
+    // The site files a recipe under collections rather than under one category
+    // on the page itself.
+    category: null,
+    author: text(recipe.author),
+    rating: value === null ? null : { value, count: count(recipe.rating_count), max: 5 },
+    nutrition: nutritionPanel(recipe),
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
 // src/sources/marmiton.ts
 var ABSOLUTE_URL = /^https?:\/\//i;
 var MARMITON_PROFILE = {
@@ -442,8 +551,8 @@ var MARMITON_PROFILE = {
   // Every page the search returns is a recipe.
   mixesReferencePages: false
 };
-var SITE_URL2 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
-var REFERENCE = /^\d+$/;
+var SITE_URL3 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
+var REFERENCE2 = /^\d+$/;
 async function readSearch(reader, query) {
   try {
     return await reader.search(query);
@@ -459,10 +568,10 @@ function marmitonAdapter(reader) {
   return {
     ...MARMITON_PROFILE,
     claims(raw) {
-      if (SITE_URL2.test(raw)) {
+      if (SITE_URL3.test(raw)) {
         return { reference: raw, why: "the address is a Marmiton page", guess: false };
       }
-      if (REFERENCE.test(raw)) {
+      if (REFERENCE2.test(raw)) {
         return {
           reference: raw,
           why: "a bare number is the shape Marmiton mints",
@@ -546,14 +655,277 @@ function marmitonDetail(payload) {
     nutrition: publishedFigures(recipe.nutrition),
     equipment: [],
     tips: [],
+    // Marmiton publishes no resting time, no word on how it lays its method
+    // out, and keeps nothing back.
+    restMinutes: null,
+    stepsAsOneBlock: null,
+    withheld: null,
     // Marmiton states no licence on a recipe page, and silence is not a grant.
     license: null
   };
 }
 
+// src/sources/ptitchef.ts
+var PTITCHEF_PROFILE = {
+  id: "ptitchef",
+  name: "Ptitchef",
+  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
+};
+var SITE_URL4 = /^https?:\/\/(?:www\.)?ptitchef\.com\//i;
+var REFERENCE3 = /^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;
+}
+function meansFor2(listing) {
+  if (count(listing.total_available) === null) {
+    return null;
+  }
+  switch (listing.kind) {
+    case "topic":
+    case "category":
+    case "standing":
+      return "recipes Ptitchef says the category page it answered this wording with holds; it counts that page rather than what the words matched";
+    case "free_text":
+    case "fridge":
+      return "rows Ptitchef served on the single page it answered this wording with; the site offers no more for it";
+    case "recipe":
+      return "the one recipe Ptitchef answered this wording with, by opening its page";
+    default:
+      return null;
+  }
+}
+function ptitchefAdapter(reader) {
+  return {
+    ...PTITCHEF_PROFILE,
+    claims(raw) {
+      if (SITE_URL4.test(raw)) {
+        const path2 = asReference2(new URL(raw).pathname);
+        return path2 === null ? null : { reference: path2, why: "the address is a Ptitchef recipe page", guess: false };
+      }
+      const path = asReference2(raw);
+      return path === null ? null : {
+        reference: path,
+        why: "the path is the shape Ptitchef mints for a recipe",
+        guess: false
+      };
+    },
+    async search(query) {
+      const outcome = await reader.searchRecipes(query);
+      const listing = outcome.data ?? {};
+      const list = rowsOf(listing.results, PTITCHEF_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!(id && title && url)) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(PTITCHEF_PROFILE.id, id),
+          source: PTITCHEF_PROFILE.id,
+          sourceName: PTITCHEF_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.image_url),
+          excerpt: text(summary?.ingredients_preview)
+        });
+      }
+      return {
+        rows,
+        skipped,
+        reportedTotal: count(listing.total_available),
+        reportedTotalMeans: meansFor2(listing),
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: ptitchefDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function ptitchefDetail(payload) {
+  const recipe = payload ?? {};
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const value = count(recipe.rating);
+  const steps = Array.isArray(recipe.steps) ? recipe.steps : [];
+  const lines = Array.isArray(recipe.ingredients) ? recipe.ingredients : [];
+  return {
+    ...detailBase(PTITCHEF_PROFILE),
+    id: namespacedId(PTITCHEF_PROFILE.id, required(recipe.id, "id", PTITCHEF_PROFILE)),
+    title: required(recipe.title, "title", PTITCHEF_PROFILE),
+    url: required(recipe.url, "url", PTITCHEF_PROFILE),
+    imageUrl: text(recipe.image_url),
+    yieldCount: count(recipe.yield_count) ?? span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: text(recipe.yield_unit) ?? span.unit,
+    ingredients: lines.filter((line) => typeof line === "string"),
+    // A step carries a picture of itself, which is not part of the method.
+    steps: steps.map((step) => text(step?.text)).filter((step) => step !== null),
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    // The site publishes no resting time of its own.
+    restMinutes: null,
+    stepsAsOneBlock: typeof recipe.steps_are_one_block === "boolean" ? recipe.steps_are_one_block : null,
+    withheld: null,
+    category: text(recipe.category),
+    author: text(recipe.author),
+    // The site prints two counts beside a rating, one of readers who rated and
+    // one of readers who wrote. Only the first is what a rating rests on, and
+    // adding them would count twice anyone who did both.
+    rating: value === null ? null : { value, count: count(recipe.rating_count), max: 5 },
+    nutrition: publishedFigures(recipe.nutrition),
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
+// src/sources/supertoinette.ts
+var SUPERTOINETTE_PROFILE = {
+  id: "supertoinette",
+  name: "Supertoinette",
+  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
+};
+var SITE_RECIPE_URL = /^https?:\/\/(?:www\.)?supertoinette\.com\/recette\/([1-9][0-9]{0,9})\//i;
+var REFERENCE4 = /^[1-9][0-9]{0,9}$/;
+function supertoinetteAdapter(reader) {
+  return {
+    ...SUPERTOINETTE_PROFILE,
+    claims(raw) {
+      const address = SITE_RECIPE_URL.exec(raw);
+      if (address?.[1]) {
+        return {
+          reference: address[1],
+          why: "the address is a Supertoinette recipe page",
+          guess: false
+        };
+      }
+      if (REFERENCE4.test(raw)) {
+        return {
+          reference: raw,
+          why: "a bare number is the shape Supertoinette mints",
+          guess: false
+        };
+      }
+      return null;
+    },
+    async search(query) {
+      const outcome = await reader.searchRecipes({ query, page: 1, category: null });
+      const listing = outcome.data?.listing ?? {};
+      const list = rowsOf(listing.results, SUPERTOINETTE_PROFILE);
+      const rows = [];
+      let skipped = outcome.skipped?.length ?? 0;
+      for (const summary of list) {
+        const id = text(summary?.id);
+        const title = text(summary?.title);
+        const url = text(summary?.url);
+        if (!(id && title && url)) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(SUPERTOINETTE_PROFILE.id, id),
+          source: SUPERTOINETTE_PROFILE.id,
+          sourceName: SUPERTOINETTE_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.image_url),
+          excerpt: text(summary?.description)
+        });
+      }
+      return {
+        rows,
+        skipped,
+        // The site prints no total anywhere on a search page. The rows of one
+        // page are not put here in its place: the site pages, so they would
+        // understate what it holds rather than count it.
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: supertoinetteDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function supertoinetteDetail(payload) {
+  const recipe = payload ?? {};
+  const rating = recipe.rating;
+  const value = count(rating?.value);
+  const published = text(recipe.yield_text);
+  const span = readYieldSpan(published);
+  const lines = Array.isArray(recipe.ingredients) ? recipe.ingredients : [];
+  return {
+    ...detailBase(SUPERTOINETTE_PROFILE),
+    id: namespacedId(SUPERTOINETTE_PROFILE.id, required(recipe.id, "id", SUPERTOINETTE_PROFILE)),
+    title: required(recipe.title, "title", SUPERTOINETTE_PROFILE),
+    url: required(recipe.url, "url", SUPERTOINETTE_PROFILE),
+    imageUrl: text(recipe.images?.[0]),
+    yieldCount: span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit,
+    // The whole line as printed, headings included: a heading dropped would
+    // merge two groups of a recipe that may each call for the same thing.
+    // The ingredient page the site links a line to is not carried, since the
+    // site links the wrong page often enough that pairing recipes by it would
+    // pair the wrong recipes.
+    ingredients: lines.map((line) => text(line?.raw)).filter((line) => line !== null),
+    steps: textList(recipe.steps),
+    publishedSections: null,
+    prepMinutes: count(recipe.prep_minutes),
+    cookMinutes: count(recipe.cook_minutes),
+    totalMinutes: count(recipe.total_minutes),
+    // The site prints this on its own, and its own total already holds it.
+    // Adding it to anything here would count it twice.
+    restMinutes: count(recipe.rest_minutes),
+    // The reader hands over the steps it read and says nothing about whether
+    // the page numbered them.
+    stepsAsOneBlock: null,
+    withheld: null,
+    category: text(recipe.category),
+    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) },
+    // This site publishes no nutrition panel at all, so there is nothing here
+    // to repeat. An empty panel would read as a page that printed one and left
+    // every figure out.
+    nutrition: null,
+    equipment: [],
+    tips: [],
+    // The site states no licence on a recipe page, and silence is not a grant.
+    license: null
+  };
+}
+
 // src/sources/registry.ts
-var SOURCE_IDS = [MARMITON_PROFILE.id, COOKBOOK_PROFILE.id];
-function buildSources(config, readers = {}) {
+var PAGE_READ_BOUNDS = { maxBodyBytes: 8e6, budgetMs: 6e4 };
+function buildSources(config, readers, logger) {
   const shared = {
     userAgent: config.userAgent,
     minIntervalMs: config.minIntervalMs,
@@ -565,9 +937,18 @@ function buildSources(config, readers = {}) {
   };
   const marmitonOptions = { config: shared };
   const cookbookOptions = { config: shared };
+  const ptitchefOptions = {
+    config: { ...shared, ...PAGE_READ_BOUNDS },
+    logger
+  };
+  const goodfoodOptions = { config: shared, logger };
+  const supertoinetteOptions = { config: shared, logger };
   return [
     marmitonAdapter(readers.marmiton ?? new MarmitonClient(marmitonOptions)),
-    cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions))
+    cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions)),
+    ptitchefAdapter(readers.ptitchef ?? new PtitchefClient(ptitchefOptions)),
+    goodfoodAdapter(readers.goodfood ?? new GoodFoodClient(goodfoodOptions)),
+    supertoinetteAdapter(readers.supertoinette ?? new SupertoinetteClient(supertoinetteOptions))
   ];
 }
 function selectSources(sources, wanted) {
@@ -590,6 +971,71 @@ function selectSources(sources, wanted) {
   }
   return chosen;
 }
+var PROFILES = [
+  MARMITON_PROFILE,
+  COOKBOOK_PROFILE,
+  PTITCHEF_PROFILE,
+  GOODFOOD_PROFILE,
+  SUPERTOINETTE_PROFILE
+];
+
+// src/sources/ids.ts
+var SEPARATOR = ":";
+function resolveId(rawId, sources) {
+  const trimmed = rawId.trim();
+  if (trimmed === "") {
+    throw invalidInput(
+      "A recipe identifier is required.",
+      `Use one of the ids search_recipes returned, such as ${example(sources)}.`
+    );
+  }
+  for (const source of sources) {
+    const prefix = `${source.id}${SEPARATOR}`;
+    if (!trimmed.toLowerCase().startsWith(prefix.toLowerCase())) {
+      continue;
+    }
+    const reference = trimmed.slice(prefix.length).trim();
+    if (reference === "") {
+      throw invalidInput(
+        `"${trimmed}" names a source and no recipe.`,
+        "Put the source's own identifier after the colon."
+      );
+    }
+    return { source, reference, inferred: null };
+  }
+  const claimed = sources.map((source) => ({ source, claim: source.claims(trimmed) })).filter(
+    (entry) => Boolean(entry.claim)
+  );
+  if (claimed.length > 1) {
+    throw invalidInput(
+      `"${trimmed}" could be an identifier on ${names(claimed.map((entry) => entry.source))}, so it names no one recipe.`,
+      `Spell it with its source, as in ${claimed.map((entry) => `${entry.source.id}:${trimmed}`).join(" or ")}.`
+    );
+  }
+  const only = claimed[0];
+  if (!only) {
+    throw invalidInput(
+      `"${trimmed}" is not an identifier any of the sources this server reads would mint.`,
+      `Call search_recipes with "${trimmed}" as the query and pass an id from a row, which reads like ${example(sources)}.`
+    );
+  }
+  return {
+    source: only.source,
+    reference: only.claim.reference,
+    inferred: only.claim.guess ? `${only.claim.why}, which is a guess: check the recipe that comes back is the one you meant` : only.claim.why
+  };
+}
+function names(sources) {
+  const all = sources.map((source) => source.name);
+  if (all.length <= 1) {
+    return all.join("");
+  }
+  return `${all.slice(0, -1).join(", ")} and ${all.at(-1)}`;
+}
+function example(sources) {
+  const first = sources[0];
+  return first ? `${first.id}${SEPARATOR}<the source's own id>` : "<source>:<id>";
+}
 
 // src/sources/wordings.ts
 var DIGITS_ONLY = /^\d+$/;
@@ -1205,7 +1651,7 @@ var RecipesClient = class {
   constructor(options = {}) {
     this.config = withGuarantees({ ...loadConfig(), ...options.config });
     this.logger = options.logger ?? createLogger(this.config.logLevel);
-    this.sources = options.sources ?? buildSources(this.config, options.readers ?? {});
+    this.sources = options.sources ?? buildSources(this.config, options.readers ?? {}, this.logger);
   }
   /** What every source sees this client call itself. */
   get userAgent() {
@@ -3973,6 +4419,18 @@ var recipeSchema = z2.object({
   prep_minutes: z2.number().int().nullable(),
   cook_minutes: z2.number().int().nullable(),
   total_minutes: z2.number().int().nullable(),
+  rest_minutes: z2.number().int().nullable().describe(
+    "Time the recipe stands, from a source that publishes it apart. It is in no other time here, and belongs to no other source's cooking time. Null where the source publishes none, which is not a dish that needs no rest."
+  ),
+  steps_as_one_block: z2.boolean().nullable().describe(
+    "Whether the source publishes the method as one block of prose rather than as steps of its own. Null where the source says neither, so a single entry is not read as step one of several."
+  ),
+  withheld: z2.object({
+    parts: z2.array(z2.string()).describe("Which parts, named as 'ingredients' or 'method'."),
+    why: z2.string().describe("What the source says about keeping them back.")
+  }).nullable().describe(
+    "A part the source published nothing of because it keeps it for its subscribers. Null from a source that withholds nothing, which is a different statement from an empty list."
+  ),
   category: z2.string().nullable(),
   author: z2.string().nullable().describe("Null on a source written by everyone who edited the page."),
   rating: ratingSchema.nullable().describe("Null on a source that carries no reader rating."),
@@ -4003,6 +4461,17 @@ function resolveFactor(recipe, servings) {
   if (servings === null) {
     return { factor: null, notes: [] };
   }
+  const held = withheldPart(recipe, "ingredients");
+  if (held !== null) {
+    return {
+      factor: null,
+      notes: [
+        mustKeep(
+          `${held}, so there is nothing here to put to ${servings}. The page states what it serves; read the lines at ${quoteForeign(recipe.url)}.`
+        )
+      ]
+    };
+  }
   if (recipe.yieldCount === null || recipe.yieldCount <= 0) {
     return {
       factor: null,
@@ -4049,7 +4518,19 @@ var METHOD_PART = {
   whole: "method",
   caution: "An empty method here is never evidence that the dish is made without one."
 };
+function withheldPart(recipe, part) {
+  if (recipe.withheld === null || !recipe.withheld.parts.includes(part)) {
+    return null;
+  }
+  return recipe.withheld.why;
+}
 function emptyPartNote(recipe, words) {
+  const held = withheldPart(recipe, words.part);
+  if (held !== null) {
+    return mustKeep(
+      `${held}, so no ${words.entry} is in this answer. The page publishes one and this server did not fail to read it; a reader who has the subscription reads the ${words.whole} at ${quoteForeign(recipe.url)}. ${words.caution}`
+    );
+  }
   const heading = headingFor(words.part, recipe.publishedSections);
   const counterpart = whatTheOtherPartHolds(words.part, recipe);
   const shown = [
@@ -4066,17 +4547,28 @@ function emptyPartNote(recipe, words) {
     `No ${words.entry} was read from this page${looked}. A page publishing no ${words.whole} and one written in a layout this server cannot follow look the same from here, so read the url before settling which this is. ${words.caution}`
   );
 }
-function buildRecipeView(recipe, options) {
-  const { factor, notes: yieldNotes } = resolveFactor(recipe, options.servings);
-  const wants = (section) => options.sections.includes(section);
-  const ingredients = factor === null || factor === 1 ? passthroughIngredients(recipe.ingredients, recipe.language) : scaleIngredients(recipe.ingredients, { factor, language: recipe.language });
-  const notes = [...yieldNotes];
+function partNotes(recipe, wants) {
+  const notes = [];
   if (wants("ingredients") && recipe.ingredients.length === 0) {
     notes.push(emptyPartNote(recipe, INGREDIENTS_PART));
   }
   if (wants("steps") && recipe.steps.length === 0) {
     notes.push(emptyPartNote(recipe, METHOD_PART));
   }
+  if (wants("steps") && recipe.stepsAsOneBlock === true && recipe.steps.length > 0) {
+    notes.push(
+      mustKeep(
+        `${recipe.sourceName} publishes this method as one block of prose rather than as steps of its own, so what is here is that block and not the first step of several.`
+      )
+    );
+  }
+  return notes;
+}
+function buildRecipeView(recipe, options) {
+  const { factor, notes: yieldNotes } = resolveFactor(recipe, options.servings);
+  const wants = (section) => options.sections.includes(section);
+  const ingredients = factor === null || factor === 1 ? passthroughIngredients(recipe.ingredients, recipe.language) : scaleIngredients(recipe.ingredients, { factor, language: recipe.language });
+  const notes = [...yieldNotes, ...partNotes(recipe, wants)];
   const rounded = ingredients.filter((entry) => entry.scaling === "rounded");
   const unscaled = ingredients.filter((entry) => entry.scaling === "unscaled");
   if (rounded.length > 0) {
@@ -4130,6 +4622,9 @@ function buildRecipeView(recipe, options) {
     prep_minutes: wants("times") ? recipe.prepMinutes : null,
     cook_minutes: wants("times") ? recipe.cookMinutes : null,
     total_minutes: wants("times") ? recipe.totalMinutes : null,
+    rest_minutes: wants("times") ? recipe.restMinutes : null,
+    steps_as_one_block: recipe.stepsAsOneBlock,
+    withheld: recipe.withheld,
     category: recipe.category,
     author: recipe.author,
     rating: recipe.rating,
@@ -4260,7 +4755,10 @@ var compareRecipesInput = strictInput({
   servings: z4.number().int().min(1).max(500).optional().describe("Rescale every version to this many, which is what makes the lists comparable."),
   sections: z4.array(z4.enum(SECTIONS)).default(["ingredients"]).describe("Which parts of each version to return. Several full recipes is a lot of text."),
   max_steps: z4.number().int().min(1).max(100).default(10).describe("Steps to return per version."),
-  max_step_chars: z4.number().int().min(80).max(4e3).default(600).describe("Characters kept per step. Raise it only if a step was cut mid-sentence.")
+  max_step_chars: z4.number().int().min(80).max(4e3).default(600).describe("Characters kept per step. Raise it only if a step was cut mid-sentence."),
+  sources: z4.array(z4.string()).optional().describe(
+    "Sources to compare, by id. Left out, every source is read, which is the point of this tool. Name two or three to put particular traditions side by side. The ids are the ones 'per_source' reports."
+  )
 });
 var compareRecipesOutput = z4.object({
   dish: z4.string(),
@@ -4277,6 +4775,9 @@ function listNames(names2) {
   }
   return `${names2.slice(0, -1).join(", ")} and ${names2.at(-1)}`;
 }
+function agrees(names2, singular, plural) {
+  return names2.length === 1 ? singular : plural;
+}
 function weighTitlesAgainstTheDish(payloads, dish, notes) {
   const weighed = payloads.map((payload) => ({
     payload,
@@ -4340,20 +4841,20 @@ function describeDifferences(recipes, payloads, sections) {
     }
     if (timed.length > 0 && untimed.length > 0) {
       differences.push(
-        `${listNames(untimed.map(nameOf))} states no time for this recipe, so there is nothing there to compare against.`
+        `${listNames(untimed.map(nameOf))} ${agrees(untimed.map(nameOf), "states", "state")} no time for this recipe, so there is nothing there to compare against.`
       );
     }
   }
   const rated = recipes.filter((recipe) => recipe.rating !== null);
   if (rated.length > 0 && rated.length < recipes.length) {
     differences.push(
-      `Only ${listNames(rated.map(nameOf))} carries a reader rating, so the versions cannot be compared on one.`
+      `Only ${listNames(rated.map(nameOf))} ${agrees(rated.map(nameOf), "carries", "carry")} a reader rating, so the versions cannot be compared on one.`
     );
   }
   const credited = recipes.filter((recipe) => recipe.author !== null);
   if (credited.length > 0 && credited.length < recipes.length) {
     differences.push(
-      `Only ${listNames(credited.map(nameOf))} credits an author; the rest are written by whoever edited the page.`
+      `Only ${listNames(credited.map(nameOf))} ${agrees(credited.map(nameOf), "credits", "credit")} an author; the rest are written by whoever edited the page.`
     );
   }
   for (const recipe of recipes) {
@@ -4368,14 +4869,18 @@ function describeDifferences(recipes, payloads, sections) {
   const silent = recipes.filter((recipe) => recipe.license === null);
   if (silent.length > 0 && silent.length < recipes.length) {
     differences.push(
-      `${listNames(silent.map(nameOf))} states no terms of use. Silence is not permission.`
+      `${listNames(silent.map(nameOf))} ${agrees(silent.map(nameOf), "states", "state")} no terms of use. Silence is not permission.`
     );
   }
   return differences;
 }
 async function runCompareRecipes(client, args) {
   try {
-    const merged = await client.searchRecipes(args.dish, 3);
+    const merged = await client.searchRecipes(
+      args.dish,
+      3,
+      args.sources
+    );
     const best = /* @__PURE__ */ new Map();
     for (const row of merged.rows) {
       if (!best.has(row.source)) {
@@ -4547,7 +5052,9 @@ var getRecipeDescription = [
   "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 getRecipeInput = strictInput({
-  id: z5.string().min(1).max(500).describe("From search_recipes, such as 'marmiton:44078' or 'cookbook:Cookbook:Carbonara'."),
+  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."
+  ),
   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."),
@@ -4857,7 +5364,9 @@ async function runSearchRecipes(client, args) {
     }
     if (results.length === 0 && answered.length === merged.reports.length) {
       notes.push(
-        "Every source answered and none holds anything under this wording. Try the dish's name in another language, or name a main ingredient instead."
+        mustKeep(
+          "Every source answered and none holds anything under this wording. Try the dish's name in another language, or name a main ingredient instead."
+        )
       );
     }
     const derived = [
@@ -4914,10 +5423,7 @@ function buildInstructions(sources) {
     "Every result carries a url. Credit the source you took a recipe from and link it; some publish under a licence that requires it, and one that states no terms at all has not granted permission."
   ].join(" ");
 }
-var INSTRUCTIONS = buildInstructions([
-  { name: "Marmiton", language: "fr" },
-  { name: "Wikibooks Cookbook", language: "en" }
-]);
+var INSTRUCTIONS = buildInstructions([...PROFILES]);
 function createServer(options = {}) {
   const config = options.config ?? loadConfig();
   const logger = options.logger ?? createLogger(config.logLevel);