mcp-recipes 1.0.0

package/dist/index.js

@@ -0,0 +1,3037 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/version.ts
+var PKG_VERSION = "1.0.0";
+var REPO_URL = "https://github.com/smeet666/mcp-recipes";
+var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
+
+// src/config.ts
+var LOG_LEVELS = ["silent", "error", "info", "debug"];
+var DEFAULT_INTERVAL_MS = 1e3;
+var MIN_ALLOWED_INTERVAL_MS = 500;
+var MAX_ALLOWED_INTERVAL_MS = 6e4;
+var DEFAULT_USER_AGENT = `mcp-recipes/${PKG_VERSION} (+${REPO_URL})`;
+function createLogger(level) {
+  const rank = LOG_LEVELS.indexOf(level);
+  const write = (at, message) => {
+    if (rank === 0 || LOG_LEVELS.indexOf(at) > rank) return;
+    process.stderr.write(`[mcp-recipes] ${at}: ${message}
+`);
+  };
+  return {
+    debug: (m) => write("debug", m),
+    info: (m) => write("info", m),
+    // A warning goes out at the error level so it survives the default
+    // setting: a caller has to know that a site was left out of an answer.
+    warn: (m) => write("error", m),
+    error: (m) => write("error", m)
+  };
+}
+function readInteger(env, name, fallback, min, max) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    process.stderr.write(
+      `[mcp-recipes] error: ${name}="${raw}" is not a whole number; using ${fallback}.
+`
+    );
+    return fallback;
+  }
+  if (value < min || value > max) {
+    process.stderr.write(
+      `[mcp-recipes] error: ${name}=${value} is outside ${min}..${max}; using ${fallback}.
+`
+    );
+    return fallback;
+  }
+  return value;
+}
+function loadConfig(env = process.env) {
+  const level = env.RECIPES_LOG_LEVEL;
+  const logLevel = level && LOG_LEVELS.includes(level) ? level : "error";
+  if (level && !LOG_LEVELS.includes(level)) {
+    process.stderr.write(
+      `[mcp-recipes] error: RECIPES_LOG_LEVEL="${level}" is not one of ${LOG_LEVELS.join(", ")}; using error.
+`
+    );
+  }
+  const custom = env.RECIPES_USER_AGENT?.trim();
+  return {
+    // A caller who wants to be recognised may say who they are, and the
+    // contact address stays attached: a site has to be able to reach a human
+    // about traffic it did not expect.
+    userAgent: custom ? `${custom} ${DEFAULT_USER_AGENT}` : DEFAULT_USER_AGENT,
+    minIntervalMs: readInteger(
+      env,
+      "RECIPES_MIN_INTERVAL_MS",
+      DEFAULT_INTERVAL_MS,
+      MIN_ALLOWED_INTERVAL_MS,
+      MAX_ALLOWED_INTERVAL_MS
+    ),
+    timeoutMs: readInteger(env, "RECIPES_TIMEOUT_MS", 2e4, 1e3, 12e4),
+    maxRetries: readInteger(env, "RECIPES_MAX_RETRIES", 3, 0, 8),
+    cacheTtlMs: readInteger(env, "RECIPES_CACHE_TTL_MS", 9e5, 0, 864e5),
+    cacheMaxEntries: readInteger(env, "RECIPES_CACHE_MAX_ENTRIES", 200, 1, 5e3),
+    logLevel
+  };
+}
+
+// src/errors.ts
+var ERROR_CODES = [
+  "not_found",
+  "invalid_input",
+  "rate_limited",
+  "parse_failure",
+  "network_error",
+  "timeout"
+];
+var RecipesError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "RecipesError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var invalidInput = (message, hint) => new RecipesError("invalid_input", message, hint ? { hint } : {});
+var parseFailure = (message, details) => new RecipesError("parse_failure", message, {
+  hint: `A site may have changed how it answers. Please report this at ${ISSUES_URL} with the arguments you used.`,
+  ...details
+});
+var timeout = (message, details) => new RecipesError("timeout", message, details ?? {});
+function toRecipesError(error) {
+  if (error instanceof RecipesError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  const raw = error;
+  const code = typeof raw?.code === "string" ? raw.code : "";
+  const known = ERROR_CODES.find((candidate) => candidate === code);
+  const details = raw && typeof raw.details === "object" && raw.details !== null ? raw.details : {};
+  return new RecipesError(known ?? "network_error", message, details);
+}
+
+// src/sources/adapter.ts
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function textList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function required(value, field, source) {
+  const found = text(value);
+  if (found === null) {
+    throw parseFailure(
+      `${source.name} answered without a readable "${field}", so there is no recipe to return.`
+    );
+  }
+  return found;
+}
+function rowsOf(value, source) {
+  if (!Array.isArray(value)) {
+    throw parseFailure(
+      `${source.name} answered in a shape this server could not read: the list of results was missing.`
+    );
+  }
+  return value;
+}
+function namespacedId(source, reference) {
+  return `${source}:${reference}`;
+}
+function publishedFigures(panel) {
+  if (typeof panel !== "object" || panel === null) return null;
+  const kept = {};
+  for (const [key, value] of Object.entries(panel)) {
+    if (typeof value === "string" && value.trim() !== "") kept[key] = value.trim();
+  }
+  return Object.keys(kept).length > 0 ? kept : null;
+}
+function readYieldSpan(published) {
+  if (published === null) return { count: null, max: null, unit: null };
+  const span = /^\s*(\d+(?:[.,]\d+)?)\s*(?:à|a|to|-|–|—|ou|or)\s*(\d+(?:[.,]\d+)?)\s*(.*)$/i.exec(
+    published
+  );
+  if (span) {
+    const low = Number(span[1].replace(",", "."));
+    const high = Number(span[2].replace(",", "."));
+    if (Number.isFinite(low) && Number.isFinite(high) && high > low) {
+      return { count: low, max: high, unit: text(span[3]) };
+    }
+  }
+  const single = /^\s*(\d+(?:[.,]\d+)?)\s*(.*)$/.exec(published);
+  if (single) {
+    const value = Number(single[1].replace(",", "."));
+    if (Number.isFinite(value)) return { count: value, max: null, unit: text(single[2]) };
+  }
+  return { count: null, max: null, unit: null };
+}
+function detailBase(source) {
+  return {
+    source: source.id,
+    sourceName: source.name,
+    language: source.language,
+    attribution: source.attribution
+  };
+}
+
+// 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[all.length - 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/cookbook.ts
+var COOKBOOK_PROFILE = {
+  id: "cookbook",
+  name: "Wikibooks Cookbook",
+  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
+};
+var SITE_URL = /^https?:\/\/en\.wikibooks\.org\/wiki\//i;
+var NAMESPACE = /^cookbook\s*:/i;
+function dishName(title) {
+  return title.replace(NAMESPACE, "").trim() || title;
+}
+function cookbookAdapter(reader) {
+  return {
+    ...COOKBOOK_PROFILE,
+    claims(raw) {
+      if (SITE_URL.test(raw)) {
+        let key;
+        try {
+          key = decodeURIComponent(raw.replace(SITE_URL, "")).replace(/_/g, " ");
+        } catch {
+          throw invalidInput(
+            `"${raw}" carries a percent sign that is not a valid escape, so the page name cannot be read.`,
+            "Pass the id search_recipes returned instead of the address."
+          );
+        }
+        return {
+          reference: key,
+          why: "the address is a page on the English Wikibooks",
+          guess: false
+        };
+      }
+      if (NAMESPACE.test(raw)) {
+        return {
+          reference: raw,
+          why: "the name opens with the namespace every Cookbook page lives under",
+          guess: false
+        };
+      }
+      return null;
+    },
+    async search(query, limit) {
+      const outcome = await reader.search(query, limit);
+      const list = rowsOf(
+        outcome.data?.results,
+        COOKBOOK_PROFILE
+      );
+      const rows = [];
+      let skipped = 0;
+      for (const summary of list) {
+        const key = text(summary?.key);
+        const title = text(summary?.title) ?? key;
+        const url = text(summary?.sourceUrl);
+        if (!key || !title || !url) {
+          skipped += 1;
+          continue;
+        }
+        rows.push({
+          id: namespacedId(COOKBOOK_PROFILE.id, key),
+          source: COOKBOOK_PROFILE.id,
+          sourceName: COOKBOOK_PROFILE.name,
+          title: dishName(title),
+          url,
+          imageUrl: text(summary?.imageUrl),
+          excerpt: text(summary?.excerpt) ?? text(summary?.description)
+        });
+      }
+      return {
+        rows,
+        skipped,
+        // The gateway states no total and offers no second page, so there is no
+        // number to report. Counting the rows returned and calling it a total
+        // would invent one.
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const outcome = await reader.getRecipe(reference);
+      return { recipe: cookbookDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function cookbookDetail(payload) {
+  const recipe = payload ?? {};
+  const license = recipe.license;
+  const licenseTitle = text(license?.title);
+  const licenseUrl = text(license?.url);
+  const published = text(recipe.yieldText);
+  const span = readYieldSpan(published);
+  return {
+    ...detailBase(COOKBOOK_PROFILE),
+    id: namespacedId(COOKBOOK_PROFILE.id, required(recipe.key, "key", COOKBOOK_PROFILE)),
+    title: dishName(required(recipe.title ?? recipe.key, "title", COOKBOOK_PROFILE)),
+    url: required(recipe.sourceUrl, "url", COOKBOOK_PROFILE),
+    // The page source carries no picture this server can address.
+    imageUrl: null,
+    yieldCount: count(recipe.servings) ?? span.count,
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: text(recipe.yieldUnit) ?? span.unit,
+    ingredients: textList(recipe.ingredients),
+    steps: textList(recipe.steps),
+    // The Cookbook publishes one time for a recipe rather than splitting it.
+    prepMinutes: null,
+    cookMinutes: null,
+    totalMinutes: count(recipe.totalMinutes),
+    category: text(recipe.category),
+    // The page is written by everyone who edited it, so it credits nobody in
+    // particular and carries no reader rating.
+    author: null,
+    rating: null,
+    nutrition: publishedFigures(recipe.nutrition),
+    equipment: textList(recipe.equipment),
+    tips: textList(recipe.tips),
+    // 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/marmiton.ts
+var MARMITON_PROFILE = {
+  id: "marmiton",
+  name: "Marmiton",
+  homeUrl: "https://www.marmiton.org",
+  language: "fr",
+  attribution: "Source: Marmiton",
+  // Every page the search returns is a recipe.
+  mixesReferencePages: false
+};
+var SITE_URL2 = /^https?:\/\/(?:www\.)?marmiton\.org\//i;
+var REFERENCE = /^\d+$/;
+function marmitonAdapter(reader) {
+  return {
+    ...MARMITON_PROFILE,
+    claims(raw) {
+      if (SITE_URL2.test(raw)) {
+        return { reference: raw, why: "the address is a Marmiton page", guess: false };
+      }
+      if (REFERENCE.test(raw)) {
+        return {
+          reference: raw,
+          why: "a bare number is the shape Marmiton mints",
+          guess: false
+        };
+      }
+      return null;
+    },
+    async search(query) {
+      const outcome = await reader.search(query);
+      const list = rowsOf(outcome.data, MARMITON_PROFILE);
+      const rows = [];
+      let skipped = 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(MARMITON_PROFILE.id, id),
+          source: MARMITON_PROFILE.id,
+          sourceName: MARMITON_PROFILE.name,
+          title,
+          url,
+          imageUrl: text(summary?.imageUrl),
+          // The result list carries a title and a picture and no prose, so
+          // there is nothing to quote here.
+          excerpt: null
+        });
+      }
+      return {
+        rows,
+        skipped,
+        // Rows on the page, including the ones this server could not read: the
+        // site saw them, and reporting only the readable ones would understate
+        // what it holds.
+        reportedTotal: rows.length + skipped,
+        reportedTotalMeans: "rows on the single page of results Marmiton serves; the site disallows paging, so this is not a catalogue count",
+        cached: outcome.cached
+      };
+    },
+    async getRecipe(reference) {
+      const ref = /^https?:\/\//i.test(reference) ? { url: reference } : { id: reference };
+      const outcome = await reader.getRecipe(ref);
+      return { recipe: marmitonDetail(outcome.data), cached: outcome.cached };
+    }
+  };
+}
+function marmitonDetail(payload) {
+  const recipe = payload ?? {};
+  const yields = recipe.recipeYield ?? {};
+  const rating = recipe.rating;
+  const value = count(rating?.value);
+  const published = text(yields.text);
+  const span = readYieldSpan(published);
+  return {
+    ...detailBase(MARMITON_PROFILE),
+    id: namespacedId(MARMITON_PROFILE.id, required(recipe.id, "id", MARMITON_PROFILE)),
+    title: required(recipe.title, "title", MARMITON_PROFILE),
+    url: required(recipe.url, "url", MARMITON_PROFILE),
+    imageUrl: text(recipe.imageUrl),
+    yieldCount: span.count ?? count(yields.count),
+    yieldMax: span.max,
+    yieldText: published,
+    yieldUnit: span.unit ?? text(yields.unit),
+    ingredients: textList(recipe.ingredients),
+    steps: textList(recipe.steps),
+    prepMinutes: count(recipe.prepMinutes),
+    cookMinutes: count(recipe.cookMinutes),
+    totalMinutes: count(recipe.totalMinutes),
+    category: text(recipe.category),
+    author: text(recipe.author),
+    rating: value === null ? null : { value, count: count(rating?.count), max: count(rating?.best) },
+    nutrition: publishedFigures(recipe.nutrition),
+    equipment: [],
+    tips: [],
+    // Marmiton 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 = {}) {
+  const shared = {
+    userAgent: config.userAgent,
+    minIntervalMs: 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 };
+  return [
+    marmitonAdapter(readers.marmiton ?? new MarmitonClient(marmitonOptions)),
+    cookbookAdapter(readers.cookbook ?? new CookbookClient(cookbookOptions))
+  ];
+}
+function selectSources(sources, wanted) {
+  if (!wanted) return sources;
+  const unknown = wanted.filter((id) => !sources.some((source) => source.id === id));
+  if (unknown.length > 0) {
+    throw invalidInput(
+      `This server reads no source called ${unknown.map((id) => `"${id}"`).join(", ")}.`,
+      `It reads ${sources.map((source) => source.id).join(", ")}.`
+    );
+  }
+  const chosen = sources.filter((source) => wanted.includes(source.id));
+  if (chosen.length === 0) {
+    throw invalidInput(
+      "A search needs at least one source.",
+      `Name one of ${sources.map((source) => source.id).join(", ")}, or leave the argument out to ask them all.`
+    );
+  }
+  return chosen;
+}
+
+// src/sources/client.ts
+var MAX_LIMIT_PER_SOURCE = 25;
+function withGuarantees(config) {
+  const defaults = loadConfig({});
+  const bounded = (value, fallback, min, max) => {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) return fallback;
+    return Math.min(max, Math.max(min, parsed));
+  };
+  const claimed = typeof config.userAgent === "string" ? config.userAgent.trim() : "";
+  const identifier = defaults.userAgent;
+  return {
+    ...config,
+    userAgent: claimed === "" || claimed.includes(identifier) ? identifier : `${claimed} ${identifier}`,
+    minIntervalMs: bounded(
+      config.minIntervalMs,
+      defaults.minIntervalMs,
+      MIN_ALLOWED_INTERVAL_MS,
+      MAX_ALLOWED_INTERVAL_MS
+    ),
+    timeoutMs: bounded(config.timeoutMs, defaults.timeoutMs, 1e3, 12e4),
+    maxRetries: bounded(config.maxRetries, defaults.maxRetries, 0, 8),
+    cacheTtlMs: bounded(config.cacheTtlMs, defaults.cacheTtlMs, 0, 864e5),
+    cacheMaxEntries: bounded(config.cacheMaxEntries, defaults.cacheMaxEntries, 1, 5e3),
+    logLevel: config.logLevel ?? defaults.logLevel
+  };
+}
+function withDeadline(work, ms, source) {
+  let timer;
+  const alarm = new Promise((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(
+        timeout(
+          `${source.name} did not answer within ${ms}ms and was left out of this answer.`
+        )
+      ),
+      ms
+    );
+    timer.unref?.();
+  });
+  return Promise.race([work, alarm]).finally(() => clearTimeout(timer));
+}
+function reportOf(attempt, count2) {
+  return {
+    source: attempt.source.id,
+    name: attempt.source.name,
+    status: attempt.error ? "failed" : "answered",
+    count: count2,
+    reportedTotal: attempt.reportedTotal,
+    reportedTotalMeans: attempt.reportedTotalMeans,
+    skipped: attempt.skipped,
+    mixesReferencePages: attempt.source.mixesReferencePages,
+    cached: attempt.cached,
+    error: attempt.error
+  };
+}
+function interleave(groups) {
+  const merged = [];
+  const longest = Math.max(0, ...groups.map((group) => group.length));
+  for (let index = 0; index < longest; index += 1) {
+    for (const group of groups) {
+      const row = group[index];
+      if (row) merged.push(row);
+    }
+  }
+  return merged;
+}
+var RecipesClient = class {
+  config;
+  logger;
+  sources;
+  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 ?? {});
+  }
+  /** What every source sees this client call itself. */
+  get userAgent() {
+    return this.config.userAgent;
+  }
+  get intervalMs() {
+    return this.config.minIntervalMs;
+  }
+  get timeoutMs() {
+    return this.config.timeoutMs;
+  }
+  get maxRetries() {
+    return this.config.maxRetries;
+  }
+  /** The sources this server reads, in the order an answer takes them. */
+  get profiles() {
+    return this.sources.map((source) => ({
+      id: source.id,
+      name: source.name,
+      language: source.language,
+      homeUrl: source.homeUrl
+    }));
+  }
+  /**
+   * The backstop deadline over one source, covering every attempt it is
+   * entitled to make and the pacing between them.
+   */
+  get deadlineMs() {
+    const attempts = this.config.maxRetries + 1;
+    return this.config.timeoutMs * attempts + this.config.minIntervalMs * this.config.maxRetries;
+  }
+  /**
+   * Ask every source the same question and merge the rows.
+   *
+   * The calls go out together, so the answer takes as long as the slowest
+   * source rather than as long as all of them. Whichever of them fail, the rest
+   * still come back, and the report says which was which.
+   */
+  async searchRecipes(query, limitPerSource, wanted) {
+    const trimmed = query.trim();
+    if (trimmed === "") {
+      throw invalidInput("A search needs something to look for.", "Name a dish or an ingredient.");
+    }
+    const chosen = selectSources(this.sources, wanted);
+    const limit = Math.max(1, Math.min(MAX_LIMIT_PER_SOURCE, Math.trunc(limitPerSource)));
+    const attempts = await Promise.all(
+      chosen.map((source) => this.searchOne(source, trimmed, limit))
+    );
+    const groups = attempts.map((attempt) => attempt.rows.slice(0, limit));
+    return {
+      rows: interleave(groups),
+      reports: attempts.map((attempt, index) => reportOf(attempt, groups[index].length))
+    };
+  }
+  async searchOne(source, query, limit) {
+    try {
+      const read = await withDeadline(source.search(query, limit), this.deadlineMs, source);
+      if (read.skipped > 0) {
+        this.logger.warn(
+          `${source.name} sent ${read.skipped} row(s) this server could not read; they were left out.`
+        );
+      }
+      return {
+        source,
+        rows: read.rows,
+        cached: read.cached,
+        reportedTotal: read.reportedTotal,
+        reportedTotalMeans: read.reportedTotalMeans,
+        skipped: read.skipped,
+        error: null
+      };
+    } catch (error) {
+      const known = toRecipesError(error);
+      this.logger.warn(`${source.name} did not answer: [${known.code}] ${known.message}`);
+      return {
+        source,
+        rows: [],
+        cached: false,
+        reportedTotal: null,
+        reportedTotalMeans: null,
+        skipped: 0,
+        error: {
+          code: known.code,
+          message: known.message,
+          ...known.details.hint ? { hint: known.details.hint } : {}
+        }
+      };
+    }
+  }
+  /**
+   * Read one recipe, from whichever source the identifier names.
+   *
+   * Only that source is called. Trying another after a miss would turn "this
+   * source has no page by this name" into somebody else's recipe with a
+   * different title, which is a worse answer than the absence it replaced.
+   */
+  async getRecipe(id) {
+    const read = resolveId(id, this.sources);
+    try {
+      const outcome = await withDeadline(
+        read.source.getRecipe(read.reference),
+        this.deadlineMs,
+        read.source
+      );
+      return { recipe: outcome.recipe, cached: outcome.cached, read };
+    } catch (error) {
+      throw toRecipesError(error);
+    }
+  }
+};
+
+// src/tools/compareRecipes.ts
+import { z as z4 } from "zod";
+
+// src/tools/recipeView.ts
+import { z as z2 } from "zod";
+
+// 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 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 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 STRUCTURAL = 3;
+var VOCABULARY = 2;
+var NAME = 1;
+function readLanguage(line, evidence = { frenchUnit: false, englishUnit: false }) {
+  let french = 0;
+  let english = 0;
+  if (FRENCH_WORDS.test(line)) french += STRUCTURAL;
+  if (FRENCH_LETTERS.test(line)) french += STRUCTURAL;
+  if (ENGLISH_WORDS.test(line)) english += STRUCTURAL;
+  if (evidence.frenchUnit) french += VOCABULARY;
+  if (evidence.englishUnit) english += VOCABULARY;
+  if (FRENCH_FOODS.test(line)) french += NAME;
+  if (ENGLISH_FOODS.test(line)) english += NAME;
+  return { language: french > english ? "fr" : "en", french, english };
+}
+
+// src/recipe/units.ts
+var SHARED_UNITS = {
+  mg: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
+  g: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  gr: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kg: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilo: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilos: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  ml: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  cl: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  dl: { canonical: "dl", kind: "measured", system: "metric", symbol: true },
+  l: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  litre: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  litres: { canonical: "l", kind: "measured", system: "metric", symbol: true }
+};
+var FRENCH_UNITS = {
+  ...SHARED_UNITS,
+  gramme: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  grammes: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kilogramme: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilogrammes: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  millilitre: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  millilitres: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  centilitre: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  centilitres: { canonical: "cl", kind: "measured", system: "metric", symbol: true },
+  // Spoons and cups: real measures, but only in sensible fractions.
+  "cuillere a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "cuilleres a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "c a soupe": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "c a s": {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  cas: {
+    canonical: "cuill\xE8re \xE0 soupe",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 soupe"
+  },
+  "cuillere a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "cuilleres a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "c a cafe": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  "c a c": {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  cac: {
+    canonical: "cuill\xE8re \xE0 caf\xE9",
+    kind: "portioned",
+    system: "none",
+    plural: "cuill\xE8res \xE0 caf\xE9"
+  },
+  verre: { canonical: "verre", kind: "portioned", system: "none" },
+  verres: { canonical: "verre", kind: "portioned", system: "none" },
+  bol: { canonical: "bol", kind: "portioned", system: "none" },
+  bols: { canonical: "bol", kind: "portioned", system: "none" },
+  tasse: { canonical: "tasse", kind: "portioned", system: "none" },
+  tasses: { canonical: "tasse", kind: "portioned", system: "none" },
+  // Packaging and natural units: countable, so they round to whole things.
+  sachet: { canonical: "sachet", kind: "portioned", system: "none" },
+  sachets: { canonical: "sachet", kind: "portioned", system: "none" },
+  gousse: { canonical: "gousse", kind: "portioned", system: "none" },
+  gousses: { canonical: "gousse", kind: "portioned", system: "none" },
+  tranche: { canonical: "tranche", kind: "portioned", system: "none" },
+  tranches: { canonical: "tranche", kind: "portioned", system: "none" },
+  botte: { canonical: "botte", kind: "portioned", system: "none" },
+  bottes: { canonical: "botte", kind: "portioned", system: "none" },
+  boite: { canonical: "bo\xEEte", kind: "portioned", system: "none", plural: "bo\xEEtes" },
+  boites: { canonical: "bo\xEEte", kind: "portioned", system: "none", plural: "bo\xEEtes" },
+  pot: { canonical: "pot", kind: "portioned", system: "none" },
+  pots: { canonical: "pot", kind: "portioned", system: "none" },
+  brique: { canonical: "brique", kind: "portioned", system: "none" },
+  briques: { canonical: "brique", kind: "portioned", system: "none" },
+  feuille: { canonical: "feuille", kind: "portioned", system: "none" },
+  feuilles: { canonical: "feuille", kind: "portioned", system: "none" },
+  branche: { canonical: "branche", kind: "portioned", system: "none" },
+  branches: { canonical: "branche", kind: "portioned", system: "none" },
+  // Held to no better than a hand: the count scales, the size of one does not.
+  // `readPartitiveMeasure` explains what else lands here.
+  bouchon: { canonical: "bouchon", kind: "approximate", system: "none" },
+  bouchons: { canonical: "bouchon", kind: "approximate", system: "none" },
+  larme: { canonical: "larme", kind: "approximate", system: "none" },
+  larmes: { canonical: "larme", kind: "approximate", system: "none" },
+  doigt: { canonical: "doigt", kind: "approximate", system: "none" },
+  doigts: { canonical: "doigt", kind: "approximate", system: "none" },
+  nuage: { canonical: "nuage", kind: "approximate", system: "none" },
+  nuages: { canonical: "nuage", kind: "approximate", system: "none" },
+  louche: { canonical: "louche", kind: "approximate", system: "none" },
+  louches: { canonical: "louche", kind: "approximate", system: "none" },
+  lichette: { canonical: "lichette", kind: "approximate", system: "none" },
+  lichettes: { canonical: "lichette", kind: "approximate", system: "none" },
+  pointe: { canonical: "pointe", kind: "approximate", system: "none" },
+  pointes: { canonical: "pointe", kind: "approximate", system: "none" },
+  pincee: { canonical: "pinc\xE9e", kind: "approximate", system: "none", plural: "pinc\xE9es" },
+  pincees: { canonical: "pinc\xE9e", kind: "approximate", system: "none", plural: "pinc\xE9es" },
+  trait: { canonical: "trait", kind: "approximate", system: "none" },
+  traits: { canonical: "trait", kind: "approximate", system: "none" },
+  filet: { canonical: "filet", kind: "approximate", system: "none" },
+  filets: { canonical: "filet", kind: "approximate", system: "none" },
+  goutte: { canonical: "goutte", kind: "approximate", system: "none", plural: "gouttes" },
+  gouttes: { canonical: "goutte", kind: "approximate", system: "none", plural: "gouttes" },
+  poignee: { canonical: "poign\xE9e", kind: "approximate", system: "none", plural: "poign\xE9es" },
+  poignees: { canonical: "poign\xE9e", kind: "approximate", system: "none", plural: "poign\xE9es" },
+  // "noix" carries its own plural mark already.
+  noix: { canonical: "noix", kind: "approximate", system: "none", plural: "noix" },
+  soupcon: { canonical: "soup\xE7on", kind: "approximate", system: "none", plural: "soup\xE7ons" },
+  soupcons: { canonical: "soup\xE7on", kind: "approximate", system: "none", plural: "soup\xE7ons" }
+};
+var ENGLISH_UNITS = {
+  ...SHARED_UNITS,
+  milligram: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
+  milligrams: { canonical: "mg", kind: "measured", system: "metric", symbol: true },
+  gram: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  grams: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  gramme: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  grammes: { canonical: "g", kind: "measured", system: "metric", symbol: true },
+  kilogram: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  kilograms: { canonical: "kg", kind: "measured", system: "metric", symbol: true },
+  milliliter: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  milliliters: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  millilitre: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  millilitres: { canonical: "ml", kind: "measured", system: "metric", symbol: true },
+  liter: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  liters: { canonical: "l", kind: "measured", system: "metric", symbol: true },
+  // Imperial mass
+  oz: { canonical: "oz", kind: "measured", system: "imperial", symbol: true },
+  ounce: { canonical: "ounce", kind: "measured", system: "imperial", plural: "ounces" },
+  ounces: { canonical: "ounce", kind: "measured", system: "imperial", plural: "ounces" },
+  lb: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
+  lbs: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
+  pound: { canonical: "pound", kind: "measured", system: "imperial", plural: "pounds" },
+  pounds: { canonical: "pound", kind: "measured", system: "imperial", plural: "pounds" },
+  // Imperial volume
+  "fl oz": { canonical: "fl oz", kind: "measured", system: "imperial", symbol: true },
+  "fluid ounce": {
+    canonical: "fluid ounce",
+    kind: "measured",
+    system: "imperial",
+    plural: "fluid ounces"
+  },
+  "fluid ounces": {
+    canonical: "fluid ounce",
+    kind: "measured",
+    system: "imperial",
+    plural: "fluid ounces"
+  },
+  pint: { canonical: "pint", kind: "measured", system: "imperial", plural: "pints" },
+  pints: { canonical: "pint", kind: "measured", system: "imperial", plural: "pints" },
+  quart: { canonical: "quart", kind: "measured", system: "imperial", plural: "quarts" },
+  quarts: { canonical: "quart", kind: "measured", system: "imperial", plural: "quarts" },
+  gallon: { canonical: "gallon", kind: "measured", system: "imperial", plural: "gallons" },
+  gallons: { canonical: "gallon", kind: "measured", system: "imperial", plural: "gallons" },
+  // Spoons and cups: real measures, but only in sensible fractions.
+  tsp: { canonical: "tsp", kind: "portioned", system: "imperial", symbol: true },
+  teaspoon: { canonical: "teaspoon", kind: "portioned", system: "imperial", plural: "teaspoons" },
+  teaspoons: { canonical: "teaspoon", kind: "portioned", system: "imperial", plural: "teaspoons" },
+  tbsp: { canonical: "Tbsp", kind: "portioned", system: "imperial", symbol: true },
+  tbs: { canonical: "Tbsp", kind: "portioned", system: "imperial", symbol: true },
+  tablespoon: {
+    canonical: "tablespoon",
+    kind: "portioned",
+    system: "imperial",
+    plural: "tablespoons"
+  },
+  tablespoons: {
+    canonical: "tablespoon",
+    kind: "portioned",
+    system: "imperial",
+    plural: "tablespoons"
+  },
+  cup: { canonical: "cup", kind: "portioned", system: "imperial", plural: "cups" },
+  cups: { canonical: "cup", kind: "portioned", system: "imperial", plural: "cups" },
+  // Packaging and natural units: countable, so they round to whole things.
+  can: { canonical: "can", kind: "portioned", system: "none" },
+  cans: { canonical: "can", kind: "portioned", system: "none" },
+  jar: { canonical: "jar", kind: "portioned", system: "none" },
+  jars: { canonical: "jar", kind: "portioned", system: "none" },
+  packet: { canonical: "packet", kind: "portioned", system: "none" },
+  packets: { canonical: "packet", kind: "portioned", system: "none" },
+  package: { canonical: "package", kind: "portioned", system: "none" },
+  packages: { canonical: "package", kind: "portioned", system: "none" },
+  sachet: { canonical: "sachet", kind: "portioned", system: "none" },
+  sachets: { canonical: "sachet", kind: "portioned", system: "none" },
+  clove: { canonical: "clove", kind: "portioned", system: "none" },
+  cloves: { canonical: "clove", kind: "portioned", system: "none" },
+  slice: { canonical: "slice", kind: "portioned", system: "none" },
+  slices: { canonical: "slice", kind: "portioned", system: "none" },
+  stick: { canonical: "stick", kind: "portioned", system: "none" },
+  sticks: { canonical: "stick", kind: "portioned", system: "none" },
+  stalk: { canonical: "stalk", kind: "portioned", system: "none" },
+  stalks: { canonical: "stalk", kind: "portioned", system: "none" },
+  sprig: { canonical: "sprig", kind: "portioned", system: "none" },
+  sprigs: { canonical: "sprig", kind: "portioned", system: "none" },
+  bunch: { canonical: "bunch", kind: "portioned", system: "none", plural: "bunches" },
+  bunches: { canonical: "bunch", kind: "portioned", system: "none", plural: "bunches" },
+  head: { canonical: "head", kind: "portioned", system: "none" },
+  heads: { canonical: "head", kind: "portioned", system: "none" },
+  sheet: { canonical: "sheet", kind: "portioned", system: "none" },
+  sheets: { canonical: "sheet", kind: "portioned", system: "none" },
+  leaf: { canonical: "leaf", kind: "portioned", system: "none", plural: "leaves" },
+  leaves: { canonical: "leaf", kind: "portioned", system: "none", plural: "leaves" },
+  ea: { canonical: "ea", kind: "portioned", system: "none", symbol: true },
+  // Held to no better than a hand: the count scales, the size of one does not.
+  // `readContainerLoad` explains what else lands here.
+  capful: { canonical: "capful", kind: "approximate", system: "none", plural: "capfuls" },
+  capfuls: { canonical: "capful", kind: "approximate", system: "none", plural: "capfuls" },
+  glug: { canonical: "glug", kind: "approximate", system: "none" },
+  glugs: { canonical: "glug", kind: "approximate", system: "none" },
+  dollop: { canonical: "dollop", kind: "approximate", system: "none" },
+  dollops: { canonical: "dollop", kind: "approximate", system: "none" },
+  squeeze: { canonical: "squeeze", kind: "approximate", system: "none" },
+  squeezes: { canonical: "squeeze", kind: "approximate", system: "none" },
+  sprinkle: { canonical: "sprinkle", kind: "approximate", system: "none" },
+  sprinkles: { canonical: "sprinkle", kind: "approximate", system: "none" },
+  sprinkling: { canonical: "sprinkling", kind: "approximate", system: "none" },
+  sprinklings: { canonical: "sprinkling", kind: "approximate", system: "none" },
+  grating: { canonical: "grating", kind: "approximate", system: "none" },
+  gratings: { canonical: "grating", kind: "approximate", system: "none" },
+  twist: { canonical: "twist", kind: "approximate", system: "none" },
+  twists: { canonical: "twist", kind: "approximate", system: "none" },
+  smidgen: { canonical: "smidgen", kind: "approximate", system: "none" },
+  smidgens: { canonical: "smidgen", kind: "approximate", system: "none" },
+  pinch: { canonical: "pinch", kind: "approximate", system: "none", plural: "pinches" },
+  pinches: { canonical: "pinch", kind: "approximate", system: "none", plural: "pinches" },
+  dash: { canonical: "dash", kind: "approximate", system: "none", plural: "dashes" },
+  dashes: { canonical: "dash", kind: "approximate", system: "none", plural: "dashes" },
+  splash: { canonical: "splash", kind: "approximate", system: "none", plural: "splashes" },
+  splashes: { canonical: "splash", kind: "approximate", system: "none", plural: "splashes" },
+  drizzle: { canonical: "drizzle", kind: "approximate", system: "none" },
+  drizzles: { canonical: "drizzle", kind: "approximate", system: "none" },
+  handful: { canonical: "handful", kind: "approximate", system: "none", plural: "handfuls" },
+  handfuls: { canonical: "handful", kind: "approximate", system: "none", plural: "handfuls" },
+  drop: { canonical: "drop", kind: "approximate", system: "none" },
+  drops: { canonical: "drop", kind: "approximate", system: "none" },
+  knob: { canonical: "knob", kind: "approximate", system: "none" },
+  knobs: { canonical: "knob", kind: "approximate", system: "none" }
+};
+var VOCABULARY2 = {
+  fr: FRENCH_UNITS,
+  en: ENGLISH_UNITS
+};
+function normalizeUnitKey(text2) {
+  return text2.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\./g, " ").replace(/\((?:s|x|es)\)/g, "").replace(/\s+/g, " ").trim();
+}
+function orderedKeys(vocabulary) {
+  return Object.keys(vocabulary).sort(
+    (a, b) => b.split(" ").length - a.split(" ").length || b.length - a.length
+  );
+}
+var UNIT_KEYS = {
+  fr: orderedKeys(FRENCH_UNITS),
+  en: orderedKeys(ENGLISH_UNITS)
+};
+function unitKeys(language) {
+  return UNIT_KEYS[language];
+}
+function lookupUnit(text2, language) {
+  return VOCABULARY2[language][normalizeUnitKey(text2)] ?? null;
+}
+var EMBEDDED = {
+  fr: buildEmbedded("fr"),
+  en: buildEmbedded("en")
+};
+function buildEmbedded(language) {
+  const keys = UNIT_KEYS[language].map((key) => key.replace(/ /g, "\\s+"));
+  return new RegExp(`\\d[\\d.,/]*\\s*(?:${keys.join("|")})\\b`, "i");
+}
+function hasEmbeddedMeasure(text2, language) {
+  return EMBEDDED[language].test(text2);
+}
+var NOT_A_MEASURE = /* @__PURE__ */ new Set([
+  "peu",
+  "beaucoup",
+  "plus",
+  "moins",
+  "assez",
+  "trop",
+  "autant",
+  "tant",
+  "moitie",
+  "quart",
+  "tiers",
+  "reste",
+  "melange",
+  "ensemble"
+]);
+function readPartitiveMeasure(text2) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+(?=(?:de|du|des)\\s|d')", "u").exec(text2);
+  if (!match) return null;
+  const word = match[1];
+  if (word.length < 3) return null;
+  if (NOT_A_MEASURE.has(normalizeUnitKey(word))) return null;
+  if (lookupUnit(word, "fr")) return null;
+  const canonical = frenchSingular(word);
+  return {
+    unit: {
+      canonical,
+      kind: "approximate",
+      system: "none",
+      plural: frenchPlural(canonical)
+    },
+    rest: text2.slice(match[0].length)
+  };
+}
+function readContainerLoad(word) {
+  const key = normalizeUnitKey(word);
+  if (!/^[a-z]{3,}fuls?$/.test(key)) return null;
+  const canonical = key.endsWith("fuls") ? key.slice(0, -1) : key;
+  return { canonical, kind: "approximate", system: "none", plural: `${canonical}s` };
+}
+function frenchSingular(word) {
+  if (/eaux$/i.test(word)) return word.slice(0, -1);
+  if (/aux$/i.test(word)) return `${word.slice(0, -3)}al`;
+  if (/[aiou]s$/i.test(word)) return word;
+  if (/s$/i.test(word) && word.length > 3) return word.slice(0, -1);
+  return word;
+}
+function frenchPlural(word) {
+  if (/[sxz]$/i.test(word)) return word;
+  if (/eau$/i.test(word)) return `${word}x`;
+  if (/al$/i.test(word)) return `${word.slice(0, -2)}aux`;
+  return `${word}s`;
+}
+var APPROXIMATE_EQUIVALENT = {
+  capful: "commonly taken as about a tablespoon, the size of a bottle cap",
+  glug: "commonly taken as about two tablespoons poured free-hand",
+  dollop: "commonly taken as about a heaped tablespoon",
+  pinch: "commonly taken as about half a teaspoon",
+  dash: "commonly taken as about an eighth of a teaspoon",
+  splash: "commonly taken as about a tablespoon",
+  handful: "commonly taken as about a quarter of a cup",
+  knob: "commonly taken as about a tablespoon of butter",
+  drizzle: "commonly taken as about a teaspoon poured in a thin line",
+  pincee: "commonly taken as about half a teaspoon",
+  poignee: "commonly taken as about a quarter of a cup",
+  bouchon: "commonly taken as about a tablespoon, the size of a bottle cap",
+  goutte: "commonly taken as a single drop",
+  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"
+};
+function approximateEquivalent(unit) {
+  return APPROXIMATE_EQUIVALENT[normalizeUnitKey(unit.canonical)] ?? null;
+}
+var PROMOTIONS = {
+  mg: { to: "g", per: 1e3, language: "en" },
+  g: { to: "kg", per: 1e3, language: "en" },
+  ml: { to: "l", per: 1e3, language: "en" },
+  cl: { to: "l", per: 100, language: "en" },
+  dl: { to: "l", per: 10, language: "en" },
+  oz: { to: "lb", per: 16, language: "en" },
+  ounce: { to: "pound", per: 16, language: "en" },
+  "fl oz": { to: "pint", per: 20, language: "en" },
+  pint: { to: "quart", per: 2, language: "en" },
+  quart: { to: "gallon", per: 4, language: "en" }
+};
+var DEMOTIONS = {
+  // Spoons and cups hold a fixed volume, so a share of one is stated in the
+  // smaller spoon rather than as a fraction no measuring set carries. The
+  // spelling of the step matches the spelling of the unit it comes from, so a
+  // line written in abbreviations stays in abbreviations, and a French line
+  // stays in French.
+  cup: { to: "tablespoon", per: 16, language: "en" },
+  tablespoon: { to: "teaspoon", per: 3, language: "en" },
+  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" },
+  kg: { to: "g", per: 1e3, language: "en" },
+  g: { to: "mg", per: 1e3, language: "en" },
+  l: { to: "cl", per: 100, language: "en" },
+  dl: { to: "cl", per: 10, language: "en" },
+  cl: { to: "ml", per: 10, language: "en" },
+  lb: { to: "oz", per: 16, language: "en" },
+  pound: { to: "ounce", per: 16, language: "en" },
+  gallon: { to: "quart", per: 4, language: "en" },
+  quart: { to: "pint", per: 2, language: "en" },
+  pint: { to: "fl oz", per: 20, language: "en" }
+};
+function demoteUnit(unit) {
+  const step = DEMOTIONS[normalizeUnitKey(unit.canonical)];
+  if (!step) return null;
+  const target = lookupUnit(step.to, step.language);
+  return target ? { unit: target, per: step.per } : null;
+}
+function isSpoonMeasure(unit) {
+  return /^(cup|tablespoon|Tbsp|teaspoon|tsp|cuillère à soupe|cuillère à café|tasse)$/.test(
+    unit.canonical
+  );
+}
+function unitDivisibility(unit) {
+  return QUARTERED_MEASURE.test(unit.canonical) ? "quarter" : "half";
+}
+var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|gousses?|tranches?|slices?)\b/i;
+function countsBarePieces(unit) {
+  return unit.canonical === "ea";
+}
+function chooseReadableUnit(unit, amount) {
+  if (unit.kind !== "measured" || !Number.isFinite(amount) || amount <= 0) {
+    return { unit, ratio: 1 };
+  }
+  let current = unit;
+  let ratio = 1;
+  while (amount * ratio < 1) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    ratio *= step.per;
+    current = step.unit;
+  }
+  const up = PROMOTIONS[normalizeUnitKey(current.canonical)];
+  if (up && amount * ratio >= up.per) {
+    const target = lookupUnit(up.to, up.language);
+    if (target) {
+      ratio /= up.per;
+      current = target;
+    }
+  }
+  return { unit: current, ratio };
+}
+function formatUnit(unit, amount, language) {
+  if (unit.symbol) return unit.canonical;
+  const singular = language === "fr" ? amount < 2 : amount <= 1;
+  if (singular) return unit.canonical;
+  return unit.plural ?? `${unit.canonical}s`;
+}
+
+// src/recipe/quantity.ts
+var VULGAR_FRACTIONS = {
+  "\xBD": 0.5,
+  "\u2153": 1 / 3,
+  "\u2154": 2 / 3,
+  "\xBC": 0.25,
+  "\xBE": 0.75,
+  "\u2155": 0.2,
+  "\u2156": 0.4,
+  "\u2157": 0.6,
+  "\u2158": 0.8,
+  "\u2159": 1 / 6,
+  "\u215A": 5 / 6,
+  "\u215B": 0.125,
+  "\u215C": 0.375,
+  "\u215D": 0.625,
+  "\u215E": 0.875
+};
+var VULGAR_CLASS = Object.keys(VULGAR_FRACTIONS).join("");
+function parseLeadingQuantity(text2, language) {
+  const trimmed = text2.trimStart();
+  const offset = text2.length - trimmed.length;
+  const mixedGlyph = new RegExp(`^(\\d+)\\s*([${VULGAR_CLASS}])`).exec(trimmed);
+  if (mixedGlyph) {
+    const whole = Number(mixedGlyph[1]);
+    const fraction2 = VULGAR_FRACTIONS[mixedGlyph[2]];
+    return { amount: whole + fraction2, length: offset + mixedGlyph[0].length };
+  }
+  const mixed = /^(\d+)\s+(\d+)\s*\/\s*(\d+)/.exec(trimmed);
+  if (mixed) {
+    const denominator = Number(mixed[3]);
+    if (denominator !== 0) {
+      return {
+        amount: Number(mixed[1]) + Number(mixed[2]) / denominator,
+        length: offset + mixed[0].length
+      };
+    }
+  }
+  const fraction = /^(\d+)\s*\/\s*(\d+)/.exec(trimmed);
+  if (fraction) {
+    const denominator = Number(fraction[2]);
+    if (denominator === 0) return null;
+    return { amount: Number(fraction[1]) / denominator, length: offset + fraction[0].length };
+  }
+  const glyph = trimmed[0];
+  if (glyph && glyph in VULGAR_FRACTIONS) {
+    return { amount: VULGAR_FRACTIONS[glyph], length: offset + 1 };
+  }
+  const decimal = (language === "fr" ? /^(\d+(?:[.,]\d+)?)/ : /^(\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:\.\d+)?)/).exec(trimmed);
+  if (decimal) {
+    const written = decimal[1];
+    const amount = Number(
+      language === "fr" ? written.replace(",", ".") : written.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 };
+  }
+  return null;
+}
+var WRITTEN_NUMERATORS = { a: 1, an: 1, one: 1, two: 2, three: 3 };
+var WRITTEN_DENOMINATORS = {
+  half: 2,
+  halves: 2,
+  third: 3,
+  thirds: 3,
+  quarter: 4,
+  quarters: 4,
+  fourth: 4,
+  fourths: 4
+};
+function parseWrittenFraction(text2) {
+  const match = /^(?:(a|an|one|two|three)[\s-]+)?(halves|half|thirds|third|quarters|quarter|fourths|fourth)\b/i.exec(
+    text2
+  );
+  if (!match) return null;
+  const numerator = match[1] ? WRITTEN_NUMERATORS[match[1].toLowerCase()] : 1;
+  const denominator = WRITTEN_DENOMINATORS[match[2].toLowerCase()];
+  if (!numerator || !denominator) return null;
+  const rest = text2.slice(match[0].length).replace(/^\s*of\s+/i, "").trimStart();
+  if (!/^an?\s/i.test(rest) && !takeUnit(rest, "en").unit) 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" ? /^\s+(à|a|ou)\s+/i : /^\s+(to|or)\s+/i;
+  const separator = written.exec(after) ?? /^\s*(–|—|-)\s*/.exec(after);
+  if (!separator) return null;
+  const high = parseLeadingQuantity(after.slice(separator[0].length), language);
+  if (!high || high.amount <= low.amount) return null;
+  return {
+    amount: low.amount,
+    max: high.amount,
+    separator: separator[1],
+    length: low.length + separator[0].length + high.length
+  };
+}
+var FRENCH_ARTICLES = { un: 1, une: 1, quelques: 3 };
+function takeUnit(text2, language) {
+  const normalized = normalizeUnitKey(text2);
+  for (const key of unitKeys(language)) {
+    if (normalized !== key && !normalized.startsWith(`${key} `)) continue;
+    const unit = lookupUnit(key, language);
+    if (!unit) continue;
+    const wordCount = key.split(" ").length;
+    const words = text2.trim().split(/\s+/);
+    return { unit, rest: words.slice(wordCount).join(" ") };
+  }
+  if (language === "en") {
+    const words = text2.trimStart().split(/\s+/);
+    const load = words[0] ? readContainerLoad(words[0]) : null;
+    if (load) return { unit: load, rest: words.slice(1).join(" ") };
+  }
+  return { unit: null, rest: text2 };
+}
+function takeUnitEitherLanguage(text2, language) {
+  const first = takeUnit(text2, language);
+  if (first.unit) return first;
+  return takeUnit(text2, language === "fr" ? "en" : "fr");
+}
+function detectLanguage(line) {
+  const text2 = line.trim();
+  const afterFigures = text2.replace(/^[\s\d.,/½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞\-–—]+/u, "").trimStart();
+  const afterArticle = afterFigures.replace(/^(?:un|une|quelques|of\s+an?|an?)\s+/iu, "");
+  const frenchUnit = takeUnit(afterArticle, "fr").unit !== null;
+  const englishUnit = takeUnit(afterArticle, "en").unit !== null;
+  return readLanguage(text2, { frenchUnit, englishUnit }).language;
+}
+function parseIngredient(line, choice = "auto") {
+  const original = line;
+  const text2 = line.trim();
+  const language = choice === "auto" ? detectLanguage(text2) : choice;
+  const empty = {
+    original,
+    language,
+    amount: null,
+    amountMax: null,
+    rangeSeparator: null,
+    unit: null,
+    alternates: [],
+    alternateStyle: null,
+    item: text2,
+    articleWord: null,
+    countMultiplier: null
+  };
+  const range = parseLeadingRange(text2, language);
+  const article = range ? null : readArticle(text2, language);
+  const quantity = range ?? parseLeadingQuantity(text2, language) ?? article;
+  if (!quantity) return empty;
+  let rest = text2.slice(quantity.length).trimStart();
+  if (language === "en") rest = rest.replace(/^(?:of\s+)?an?\s+/i, "");
+  const multiplier = readCountMultiplier(rest);
+  if (multiplier) rest = multiplier.rest;
+  const times = multiplier?.times ?? 1;
+  const leading = takeLeadingUnit(rest, language, quantity === article);
+  rest = leading.rest;
+  const bracketed = takeAlternates(rest, language);
+  rest = bracketed.rest;
+  const slashed = bracketed.measures.length > 0 ? null : takeSlashAlternates(rest, language);
+  if (slashed) rest = slashed.rest;
+  return {
+    original,
+    language,
+    amount: quantity.amount * times,
+    amountMax: range === null ? null : range.max * times,
+    rangeSeparator: range?.separator ?? null,
+    unit: leading.unit,
+    alternates: slashed ? slashed.measures : bracketed.measures,
+    alternateStyle: slashed ? "slash" : bracketed.measures.length > 0 ? "bracket" : null,
+    item: stripItemLead(rest, language),
+    articleWord: quantity === article ? article?.word ?? null : null,
+    countMultiplier: multiplier?.times ?? null
+  };
+}
+function readArticle(text2, language) {
+  const counts = (rest) => takeLeadingUnit(rest, language, true).unit !== null || readCountMultiplier(rest) !== null;
+  if (language === "fr") {
+    const match = /^\s*(un|une|quelques)\b\s*/i.exec(text2);
+    if (!match) return null;
+    if (!counts(text2.slice(match[0].length))) return null;
+    const word = match[1];
+    return { amount: FRENCH_ARTICLES[word.toLowerCase()], length: match[0].length, word };
+  }
+  const article = /^an?\s+/i.exec(text2);
+  if (!article) return null;
+  if (!counts(text2.slice(article[0].length))) return null;
+  return { amount: 1, length: article[0].length, word: article[0].trim() };
+}
+var COUNT_MULTIPLIERS = {
+  dozen: 12,
+  dozens: 12,
+  douzaine: 12,
+  douzaines: 12
+};
+function readCountMultiplier(text2) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+", "u").exec(text2);
+  if (!match) return null;
+  const times = COUNT_MULTIPLIERS[normalizeUnitKey(match[1])];
+  if (times === void 0) return null;
+  return { times, rest: text2.slice(match[0].length) };
+}
+function takeLeadingUnit(text2, language, fromArticle) {
+  const taken = takeUnit(text2, language);
+  if (taken.unit) return taken;
+  if (language === "fr" && fromArticle) {
+    const measure = readPartitiveMeasure(text2);
+    if (measure) return { unit: measure.unit, rest: measure.rest };
+  }
+  return taken;
+}
+function stripItemLead(text2, language) {
+  if (language === "fr") {
+    return text2.replace(/^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i, "").replace(/^(?:une|un)\s+/i, "").trim();
+  }
+  return text2.replace(/^of\s+/i, "").replace(/^an?\s+/i, "").trim();
+}
+function takeAlternates(text2, language) {
+  if (!text2.startsWith("(")) return { measures: [], rest: text2 };
+  const close = text2.indexOf(")");
+  if (close < 0) return { measures: [], rest: text2 };
+  const inside = text2.slice(1, close);
+  const parts = inside.split("/").map((part) => part.trim());
+  const measures = [];
+  for (const part of parts) {
+    const range = parseLeadingRange(part, language);
+    const quantity = range ?? parseLeadingQuantity(part, language);
+    if (!quantity) return { measures: [], rest: text2 };
+    const after = takeUnitEitherLanguage(part.slice(quantity.length).trimStart(), language);
+    if (!after.unit || after.rest.trim() !== "") return { measures: [], rest: text2 };
+    measures.push({
+      amount: quantity.amount,
+      amountMax: range?.max ?? null,
+      rangeSeparator: range?.separator ?? null,
+      unit: after.unit
+    });
+  }
+  if (measures.length === 0) return { measures: [], rest: text2 };
+  return { measures, rest: text2.slice(close + 1).trimStart() };
+}
+function takeSlashAlternates(text2, language) {
+  const measures = [];
+  let rest = text2;
+  while (rest.startsWith("/")) {
+    const after = rest.slice(1).trimStart();
+    const range = parseLeadingRange(after, language);
+    const quantity = range ?? parseLeadingQuantity(after, language);
+    if (!quantity) break;
+    const taken = takeUnitEitherLanguage(after.slice(quantity.length).trimStart(), language);
+    if (!taken.unit) break;
+    measures.push({
+      amount: quantity.amount,
+      amountMax: range?.max ?? null,
+      rangeSeparator: range?.separator ?? null,
+      unit: taken.unit
+    });
+    rest = taken.rest.trimStart();
+  }
+  return measures.length > 0 ? { measures, rest } : null;
+}
+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;
+  };
+  if (!Number.isFinite(amount)) return "";
+  if (Number.isInteger(amount)) return String(amount);
+  if (options.fractions === false) return decimal(amount);
+  const whole = Math.floor(amount);
+  const rest = amount - whole;
+  const known = [
+    [0.25, "1/4"],
+    [1 / 3, "1/3"],
+    [0.5, "1/2"],
+    [2 / 3, "2/3"],
+    [0.75, "3/4"]
+  ];
+  for (const [value, label] of known) {
+    if (Math.abs(rest - value) < 0.02) return whole > 0 ? `${whole} ${label}` : label;
+  }
+  return decimal(amount);
+}
+
+// src/recipe/scale.ts
+function roundTo(value, step) {
+  return Math.round(Math.round(value / step) * step * 100) / 100;
+}
+function roundMeasured(value) {
+  if (value >= 100) return roundTo(value, 5);
+  if (value >= 10) return roundTo(value, 1);
+  if (value >= 1) return roundTo(value, 0.1);
+  return Math.round(value * 100) / 100;
+}
+var SMALLEST_USABLE_FRACTION = 0.25;
+var SMALLEST_USABLE = {
+  whole: 1,
+  half: 0.5,
+  quarter: 0.25
+};
+function isHalfStep(value) {
+  return Math.abs(value * 2 - Math.round(value * 2)) < 1e-9;
+}
+function trim(value) {
+  return Math.round(value * 100) / 100;
+}
+function roundCountable(value, divisibility, ceiling) {
+  if (value <= 0) return { value: 0, clamped: false };
+  const floor = SMALLEST_USABLE[divisibility];
+  if (divisibility !== "whole" && value >= floor && isHalfStep(value)) {
+    return { value: trim(value), clamped: false };
+  }
+  if (divisibility === "whole") {
+    if (value < 0.5) return { value: floor, clamped: true };
+    return { value: Math.round(value), clamped: false };
+  }
+  if (value < floor) return { value: floor, clamped: true };
+  if (value < 1) {
+    const steps = divisibility === "quarter" ? [0.25, 1 / 3, 0.5, 2 / 3, 0.75, 1] : [0.5, 1];
+    const candidates = steps.filter(
+      (candidate) => candidate >= floor && candidate <= Math.max(ceiling, floor)
+    );
+    let closest = candidates[0];
+    for (const candidate of candidates) {
+      if (Math.abs(value - candidate) < Math.abs(value - closest)) closest = candidate;
+    }
+    return { value: trim(closest), clamped: false };
+  }
+  return { value: Math.round(value), clamped: false };
+}
+function roundSpoon(value, ceiling) {
+  if (value <= 0) return { value: 0, clamped: false };
+  if (value < 1) {
+    const candidates = [SMALLEST_USABLE_FRACTION, 1 / 3, 0.5, 2 / 3, 0.75, 1].filter(
+      (candidate) => candidate <= Math.max(ceiling, SMALLEST_USABLE_FRACTION)
+    );
+    let closest = candidates[0];
+    for (const candidate of candidates) {
+      if (Math.abs(value - candidate) < Math.abs(value - closest)) closest = candidate;
+    }
+    return { value: trim(closest), clamped: value < SMALLEST_USABLE_FRACTION };
+  }
+  return { value: roundTo(value, 0.5), clamped: false };
+}
+function stepDownSpoon(unit, reference) {
+  let current = unit;
+  let ratio = 1;
+  while (reference * ratio < 1 && !isHalfStep(reference * ratio)) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    ratio *= step.per;
+    current = step.unit;
+  }
+  return { unit: current, ratio };
+}
+var EXACT_WITHIN = 0.01;
+var EXACT_SHARE = 5e-3;
+function landedExactly(exact, amount) {
+  const gap = Math.abs(exact - amount);
+  if (gap > EXACT_WITHIN) return false;
+  return exact === 0 || gap / Math.abs(exact) <= EXACT_SHARE;
+}
+function scaleMeasure(low, high, unit, factor, divisibility) {
+  const raws = high === null ? [low * factor] : [low * factor, high * factor];
+  const sources = high === null ? [low] : [low, high];
+  const positive = raws.filter((raw) => raw > 0);
+  const reference = positive.length > 0 ? Math.min(...positive) : raws[0];
+  const inUnit = (target, ratio) => ({
+    bounds: raws.map((raw, index) => {
+      const exact = raw * ratio;
+      const rounded = roundMeasured(exact);
+      const usable = rounded === 0 && exact > 0 ? Number(exact.toPrecision(2)) : rounded;
+      const ceiling = factor < 1 ? sources[index] * ratio : Number.POSITIVE_INFINITY;
+      return {
+        amount: Math.min(usable, ceiling),
+        exact,
+        clamped: false,
+        raw
+      };
+    }),
+    unit: target
+  });
+  if (unit && unit.kind === "measured") {
+    const chosen = chooseReadableUnit(unit, reference);
+    return inUnit(chosen.unit, chosen.ratio);
+  }
+  if (unit && isSpoonMeasure(unit)) {
+    const stepped = stepDownSpoon(unit, reference);
+    if (stepped.ratio !== 1) return inUnit(stepped.unit, stepped.ratio);
+    const bounds2 = raws.map((raw, index) => {
+      const ceiling = factor < 1 ? sources[index] : Number.POSITIVE_INFINITY;
+      const rounded = roundSpoon(raw, ceiling);
+      return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw };
+    });
+    return { bounds: bounds2, unit };
+  }
+  const bounds = raws.map((raw, index) => {
+    const ceiling = factor < 1 ? sources[index] : Number.POSITIVE_INFINITY;
+    const rounded = roundCountable(raw, divisibility, ceiling);
+    return { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw };
+  });
+  return { bounds, unit };
+}
+var PORTION_SIZED_ITEM = new RegExp(
+  "\\b(?:shrimps?|prawns?|langoustines?|mussels?|hazelnuts?|peppercorns?|junipers?|grains?|anise|crevettes?|gambas|moules?|noisettes?|geni\xE8vres?|genievres?|anis)\\b",
+  "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",
+  "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 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" : /\bcloves?\b/i.test(item);
+  if (!counted) return null;
+  return /\bgarlic\b/i.test(item) ? "quarter" : "whole";
+}
+var BLANC_OF = /\bblancs?\s+d(?:e\s|['’])/iu;
+var BLANC_OF_EGG = /\bblancs?\s+d(?:e\s|['’])\s*(?:oeufs?|œufs?)\b/iu;
+function blancDivisibility(item) {
+  if (!BLANC_OF.test(item)) return null;
+  return BLANC_OF_EGG.test(item) ? "whole" : "half";
+}
+function divisibilityOf(unit, item) {
+  const clove = cloveDivisibility(unit, item);
+  if (clove) return clove;
+  if (unit && !countsBarePieces(unit)) return unitDivisibility(unit);
+  const blanc = blancDivisibility(item);
+  if (blanc) return blanc;
+  if (WHOLE_ITEM.test(item)) return "whole";
+  if (PORTION_SIZED_ITEM.test(item)) return "whole";
+  if (HALVED_ITEM.test(item)) return "half";
+  if (HALVED_CUT.test(item)) return "half";
+  if (QUARTERED_MEASURE.test(item)) return "quarter";
+  return QUARTERED_ITEM.test(item) ? "quarter" : "half";
+}
+var INVARIABLE_ITEM = /* @__PURE__ */ new Set([
+  "anise",
+  "ananas",
+  "asparagus",
+  "bacon",
+  "basil",
+  "beef",
+  "bison",
+  "broccoli",
+  "butter",
+  "celery",
+  "cilantro",
+  "citrus",
+  "cinnamon",
+  "cocoa",
+  "cod",
+  "coriander",
+  "corn",
+  "cornstarch",
+  "couscous",
+  "cream",
+  "deer",
+  "fish",
+  "flour",
+  "gambas",
+  "garlic",
+  "ginger",
+  "ham",
+  "honey",
+  "hummus",
+  "jus",
+  "kale",
+  "lamb",
+  "macaroni",
+  "milk",
+  "miso",
+  "musk",
+  "moose",
+  "mutton",
+  "nutmeg",
+  "oil",
+  "okra",
+  "oregano",
+  "parsley",
+  "pasta",
+  "pork",
+  "quinoa",
+  "rice",
+  "rosemary",
+  "saffron",
+  "salmon",
+  "salt",
+  "shrimp",
+  "spinach",
+  "squid",
+  "sugar",
+  "thyme",
+  "tofu",
+  "trout",
+  "tuna",
+  "vanilla",
+  "veal",
+  "venison",
+  "vinegar",
+  "water",
+  "yeast",
+  "yogurt"
+]);
+var IRREGULAR_PLURAL = {
+  calf: "calves",
+  chili: "chilies",
+  chilli: "chillies",
+  goose: "geese",
+  half: "halves",
+  knife: "knives",
+  leaf: "leaves",
+  loaf: "loaves",
+  mango: "mangoes",
+  potato: "potatoes",
+  shelf: "shelves",
+  tomato: "tomatoes"
+};
+var IRREGULAR_SINGULAR = Object.fromEntries(
+  Object.entries(IRREGULAR_PLURAL).map(([one, many]) => [many, one])
+);
+function matchCase(source, replacement) {
+  if (source[0] === source[0]?.toUpperCase() && source.slice(1) === source.slice(1).toLowerCase()) {
+    return replacement[0].toUpperCase() + replacement.slice(1);
+  }
+  return replacement;
+}
+function toEnglishPlural(word) {
+  const key = word.toLowerCase();
+  if (INVARIABLE_ITEM.has(key)) return word;
+  const irregular = IRREGULAR_PLURAL[key];
+  if (irregular) return matchCase(word, irregular);
+  if (/(?:ch|sh|s|x|z)$/i.test(word)) return `${word}es`;
+  if (/[^aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
+  if (/(?:[^f]f|fe)$/i.test(word)) return `${word.replace(/fe?$/i, "")}ves`;
+  return `${word}s`;
+}
+function toEnglishSingular(word) {
+  const key = word.toLowerCase();
+  if (INVARIABLE_ITEM.has(key)) return word;
+  const irregular = IRREGULAR_SINGULAR[key];
+  if (irregular) return matchCase(word, irregular);
+  if (/ies$/i.test(word) && word.length > 4) return `${word.slice(0, -3)}y`;
+  if (/(?:ch|sh|s|x|z)es$/i.test(word)) return word.slice(0, -2);
+  if (/ss$/i.test(word)) return word;
+  if (/s$/i.test(word)) return word.slice(0, -1);
+  return word;
+}
+function agreeInEnglish(item, amount) {
+  if (!item) return item;
+  const comma = item.indexOf(",");
+  const head = comma < 0 ? item : item.slice(0, comma);
+  const tail = comma < 0 ? "" : item.slice(comma);
+  const preposition = / of /i.exec(head);
+  if (preposition) {
+    const counted = agreeInEnglish(head.slice(0, preposition.index), amount);
+    return `${counted}${head.slice(preposition.index)}${tail}`;
+  }
+  const words = head.trimEnd().split(" ");
+  const last = words[words.length - 1] ?? "";
+  if (!/^[A-Za-z]+$/.test(last) || last.length <= 2) return item;
+  const wantsPlural = amount > 1;
+  const plural = toEnglishPlural(last);
+  const singular = toEnglishSingular(last);
+  const isPlural = last.toLowerCase() !== singular.toLowerCase();
+  if (wantsPlural && !isPlural) words[words.length - 1] = plural;
+  else if (!wantsPlural && isPlural) words[words.length - 1] = singular;
+  else return item;
+  return `${words.join(" ")}${tail}`;
+}
+var INVARIABLE_FRENCH_NOUN = /* @__PURE__ */ new Set([
+  "ananas",
+  "anis",
+  "brebis",
+  "cassis",
+  "colis",
+  "coulis",
+  "couscous",
+  "gambas",
+  "houmous",
+  "jus",
+  "mais",
+  "pastis",
+  "pois",
+  "radis",
+  "ris",
+  "souris",
+  "tamis",
+  "tapas"
+]);
+var AGREEABLE_ADJECTIVES = /* @__PURE__ */ new Set([
+  "entier",
+  "entiere",
+  "etoile",
+  "etoilee",
+  "moyen",
+  "moyenne",
+  "petit",
+  "petite",
+  "grand",
+  "grande",
+  "mur",
+  "mure",
+  "vert",
+  "verte",
+  "rouge",
+  "jaune",
+  "noir",
+  "noire",
+  "blanc",
+  "blanche",
+  "rond",
+  "ronde",
+  "hache",
+  "hachee",
+  "coupe",
+  "coupee",
+  "rape",
+  "rapee",
+  "pele",
+  "pelee",
+  "epluche",
+  "epluchee",
+  "denoyaute",
+  "denoyautee",
+  "emince",
+  "emincee"
+]);
+function foldWord(word) {
+  return word.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
+}
+function agreeTrailingAdjective(word, wantsPlural) {
+  const folded = foldWord(word);
+  const isPlural = folded.endsWith("s");
+  const singular = isPlural ? word.slice(0, -1) : word;
+  if (!AGREEABLE_ADJECTIVES.has(foldWord(singular))) return null;
+  if (wantsPlural === isPlural) return null;
+  return wantsPlural ? `${word}s` : singular;
+}
+function agreeInFrench(item, amount) {
+  if (!item) return item;
+  const words = item.split(" ");
+  const head = words[0] ?? "";
+  if (head.length <= 3) return item;
+  const wantsPlural = amount >= 2;
+  const isPlural = /s$|eaux$|aux$/i.test(head);
+  if (wantsPlural && !isPlural) {
+    if (/[sxz]$/i.test(head)) {
+    } else if (/eau$/i.test(head)) words[0] = `${head}x`;
+    else if (/al$/i.test(head)) words[0] = `${head.slice(0, -2)}aux`;
+    else words[0] = `${head}s`;
+  } else if (!wantsPlural && isPlural) {
+    if (/eaux$/i.test(head)) words[0] = head.slice(0, -1);
+    else if (/aux$/i.test(head)) words[0] = `${head.slice(0, -3)}al`;
+    else if (INVARIABLE_FRENCH_NOUN.has(foldWord(head))) {
+    } else words[0] = head.slice(0, -1);
+  }
+  const last = words.length - 1;
+  if (last > 0) {
+    const adjective = agreeTrailingAdjective(words[last], wantsPlural);
+    if (adjective) words[last] = adjective;
+  }
+  return words.join(" ");
+}
+function agreeWithAmount(item, amount, language) {
+  return language === "fr" ? agreeInFrench(item, amount) : agreeInEnglish(item, amount);
+}
+var MUTE_H_WORDS = /^(?:huile|huiles|huitre|huitres|huître|huîtres|herbe|herbes|hysope)\b/i;
+function joinItem(item, language) {
+  if (!item) return "";
+  if (language === "en") return ` ${item}`;
+  const elides = /^[aeiouàâäéèêëîïôöûü]/i.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
+};
+function splitBranch(text2, parsed) {
+  const itemStart = parsed.item ? text2.indexOf(parsed.item) : text2.length;
+  if (itemStart < 0) return null;
+  const separator = BRANCH_SEPARATORS[parsed.language];
+  separator.lastIndex = 0;
+  for (let match = separator.exec(text2); match; match = separator.exec(text2)) {
+    if (match.index < itemStart) continue;
+    const tail = text2.slice(match.index + match[0].length);
+    if (parseIngredient(tail, parsed.language).amount === null) continue;
+    return { head: text2.slice(0, match.index), separator: match[0], tail };
+  }
+  return null;
+}
+function scaleIngredient(line, options) {
+  const { factor } = options;
+  if (factor === 1) return passthroughIngredient(line, options.language);
+  const text2 = line.trim();
+  const parsed = parseIngredient(text2, options.language ?? "auto");
+  const branch = splitBranch(text2, parsed);
+  if (branch) return scaleBranchedLine(line, branch, { ...options, language: parsed.language });
+  return scaleSingleLine(line, options);
+}
+function scaleBranchedLine(line, branch, options) {
+  const head = scaleSingleLine(branch.head, options);
+  if (head.scaling === "unscaled") return { ...head, text: line.trim(), original: line };
+  const tail = scaleAlternative(branch.tail, options);
+  const result = {
+    ...head,
+    original: line,
+    text: `${head.text}${branch.separator}${tail.text}`,
+    scaling: "rounded"
+  };
+  const branchNote = tail.rewritten ? "This line offers a choice between two quantities, and each was scaled on its own. How far one stands for the other is the page's own claim." : "This line carries a further quantity after the first one, and only the first was scaled. Read the rest as published.";
+  result.note = head.note ? `${head.note} ${branchNote}` : branchNote;
+  return result;
+}
+function scaleAlternative(tail, options) {
+  const parsed = parseIngredient(tail, options.language ?? "auto");
+  const published = tail.trim();
+  if (parsed.amount === null) return { text: published, rewritten: false };
+  const largest = (parsed.amountMax ?? parsed.amount) * options.factor;
+  if (largest < 1) return { text: published, rewritten: false };
+  return { text: scaleIngredient(tail, options).text, rewritten: true };
+}
+function scaleSingleLine(line, options) {
+  const { factor } = options;
+  const parsed = parseIngredient(line, options.language ?? "auto");
+  const language = parsed.language;
+  if (parsed.amount === null) {
+    return {
+      text: parsed.original,
+      original: parsed.original,
+      scaling: "unscaled",
+      amount: null,
+      amountMax: null,
+      unit: null,
+      language,
+      note: "No quantity given; adjust to taste."
+    };
+  }
+  const divisibility = divisibilityOf(parsed.unit, parsed.item);
+  const primary = scaleMeasure(parsed.amount, parsed.amountMax, parsed.unit, factor, divisibility);
+  const alternates = parsed.alternates.map((measure) => renderMeasure(measure, factor, language));
+  const primaryBounds = primary.bounds;
+  const alternateBounds = alternates.flatMap((entry) => entry.bounds);
+  const movedPrimary = primaryBounds.some((b) => !landedExactly(b.exact, b.amount));
+  const movedAlternate = alternateBounds.some((b) => !landedExactly(b.exact, b.amount));
+  const clamped = [...primaryBounds, ...alternateBounds].find((bound) => bound.clamped) ?? null;
+  const restated = parsed.alternateStyle === "slash";
+  const low = primaryBounds[0];
+  const high = primaryBounds[1] ?? null;
+  const unit = primary.unit;
+  const shown = high?.amount ?? low.amount;
+  const asText = (value) => formatAmount(value, language, { fractions: unit?.kind !== "measured" });
+  const collapsed = high !== null && high.amount === low.amount;
+  const amountText = renderRange(
+    asText(low.amount),
+    high === null || collapsed ? null : asText(high.amount),
+    parsed.rangeSeparator
+  );
+  const named = unit && !countsBarePieces(unit) ? unit : null;
+  const unitLabel = named ? ` ${formatUnit(named, shown, language)}` : "";
+  const alternateTexts = alternates.map((entry) => entry.text);
+  const altLabel = alternates.length === 0 ? "" : parsed.alternateStyle === "slash" ? ` / ${alternateTexts.join(" / ")}` : ` (${alternateTexts.join(" / ")})`;
+  const counted = agreeWithAmount(parsed.item, shown, language);
+  const itemLabel = named ? joinItem(parsed.item, language) : counted ? ` ${counted}` : "";
+  const result = {
+    text: `${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
+    original: parsed.original,
+    scaling: movedPrimary || movedAlternate || restated ? "rounded" : "scaled",
+    amount: low.amount,
+    amountMax: collapsed ? null : high?.amount ?? null,
+    unit: named?.canonical ?? null,
+    language
+  };
+  const asPublished = (value, source) => `${formatAmount(value, language, { fractions: false })}${source ? ` ${formatUnit(source, value, language)}` : ""}`;
+  const sentences = [];
+  if (clamped) {
+    sentences.push(
+      `Clamped up to ${formatAmount(clamped.amount, language)} from ${formatAmount(Math.round(clamped.raw * 1e3) / 1e3, language)}, the smallest amount worth measuring. This line no longer holds its share of the recipe.`
+    );
+  } else if (movedPrimary) {
+    const moved = primaryBounds.filter((bound) => !landedExactly(bound.exact, bound.amount));
+    sentences.push(
+      moved.map(
+        (bound) => `Rounded ${bound.amount > bound.exact ? "up" : "down"} from ${asPublished(bound.raw, parsed.unit)}.`
+      ).join(" ")
+    );
+  } else if (movedAlternate) {
+    sentences.push(
+      `The amount is exact; the equivalent ${restated ? "beside it" : "in brackets"} was rounded to stay readable.`
+    );
+  } else if (restated) {
+    sentences.push(
+      "This line states one quantity twice, and both readings were scaled. They agree as closely as the page wrote them, and no closer."
+    );
+  }
+  if (hasEmbeddedMeasure(parsed.item, language)) {
+    sentences.push(
+      "This line carries a further quantity after the first one, and only the first was scaled. Read the rest as published."
+    );
+  }
+  if (collapsed) {
+    sentences.push("The page gave a range, and at this size both ends come to the same amount.");
+  }
+  if (unit?.kind === "measured" && low.amount > 0 && low.amount < 0.05) {
+    sentences.push(
+      "This is smaller than a kitchen scale resolves. Make a larger batch, or measure it by eye."
+    );
+  }
+  if (sentences.length > 0) result.note = sentences.join(" ");
+  if (parsed.unit && parsed.unit.kind === "approximate") {
+    result.note = withApproximateNote(parsed.unit, result.note);
+  }
+  if (parsed.articleWord) {
+    const stood = (parsed.amount ?? 0) / (parsed.countMultiplier ?? 1);
+    const read = `"${parsed.articleWord}" read as ${formatAmount(stood, language)}.`;
+    result.note = result.note ? `${read} ${result.note}` : read;
+  }
+  return result;
+}
+function withApproximateNote(unit, existing) {
+  const equivalence = approximateEquivalent(unit);
+  const sentence = `A ${unit.canonical} is an approximate measure${equivalence ? `, ${equivalence}` : ""}. The count was scaled and the size of one is the cook's.`;
+  return existing ? `${existing} ${sentence}` : sentence;
+}
+function renderMeasure(measure, factor, language) {
+  const scaled = scaleMeasure(
+    measure.amount,
+    measure.amountMax,
+    measure.unit,
+    factor,
+    divisibilityOf(measure.unit, "")
+  );
+  const low = scaled.bounds[0];
+  const high = scaled.bounds[1] ?? null;
+  const unit = scaled.unit;
+  const shown = high?.amount ?? low.amount;
+  const asText = (value) => formatAmount(value, language, { fractions: unit?.kind !== "measured" });
+  return {
+    text: `${renderRange(
+      asText(low.amount),
+      high === null ? null : asText(high.amount),
+      measure.rangeSeparator
+    )}${unit ? ` ${formatUnit(unit, shown, language)}` : ""}`,
+    bounds: scaled.bounds
+  };
+}
+function renderRange(low, high, separator) {
+  if (high === null || separator === null) return low;
+  return /^[-–—]$/.test(separator) ? `${low}${separator}${high}` : `${low} ${separator} ${high}`;
+}
+function scaleIngredients(lines, options) {
+  return lines.map((line) => scaleIngredient(line, options));
+}
+function passthroughIngredient(line, language = "auto") {
+  const parsed = parseIngredient(line, language);
+  const result = {
+    text: parsed.original,
+    original: parsed.original,
+    scaling: parsed.amount === null ? "unscaled" : "scaled",
+    amount: parsed.amount,
+    amountMax: parsed.amountMax,
+    unit: parsed.unit?.canonical ?? null,
+    language: parsed.language
+  };
+  if (parsed.amount === null) result.note = "No quantity given; adjust to taste.";
+  else if (parsed.unit?.kind === "approximate") {
+    result.note = withApproximateNote(parsed.unit, void 0);
+  }
+  return result;
+}
+function passthroughIngredients(lines, language = "auto") {
+  return lines.map((line) => passthroughIngredient(line, language));
+}
+
+// src/tools/shared.ts
+import { z } from "zod";
+var MAX_TEXT_CHARS = 2200;
+var rowSchema = z.object({
+  id: z.string().describe("Pass this to get_recipe. It names its source, so nothing has to be guessed."),
+  source: z.string().describe("Which source published this row."),
+  source_name: z.string(),
+  title: z.string(),
+  url: z.string().describe("The recipe's own page. Show this when citing it."),
+  image_url: z.string().nullable(),
+  excerpt: z.string().nullable().describe("The gloss or matching passage the source offered, when it offered one.")
+});
+var reportSchema = z.object({
+  source: z.string(),
+  name: z.string(),
+  status: z.enum(["answered", "failed"]).describe("Whether this source replied at all."),
+  count: z.number().int().describe("Rows this source contributed to the answer."),
+  reported_total: z.number().int().nullable().describe("What the source said it saw. Null when it states no number at all."),
+  reported_total_means: z.string().nullable().describe(
+    "What 'reported_total' counts on this source. Counts are never summed across sources."
+  ),
+  skipped: z.number().int().describe("Rows this source sent in a shape the server could not read, and left out."),
+  cached: z.boolean().describe("Served from this server's short-lived in-memory cache."),
+  error: z.object({
+    code: z.string(),
+    message: z.string(),
+    hint: z.string().optional()
+  }).nullable().describe("Why this source did not answer. Null when it did.")
+});
+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."
+  ),
+  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."),
+  note: z.string().optional().describe("What happened to this line, when anything did.")
+});
+function toIngredientPayload(entry) {
+  return {
+    text: entry.text,
+    original: entry.original,
+    scaling: entry.scaling,
+    amount: entry.amount,
+    amount_max: entry.amountMax,
+    unit: entry.unit,
+    language: entry.language,
+    ...entry.note ? { note: entry.note } : {}
+  };
+}
+function toRowPayload(row) {
+  return {
+    id: row.id,
+    source: row.source,
+    source_name: row.sourceName,
+    title: row.title,
+    url: row.url,
+    image_url: row.imageUrl,
+    // An excerpt is a source's own prose, and a long one crowds out the rows it
+    // was meant to help choose between.
+    excerpt: row.excerpt === null ? null : truncate(row.excerpt, MAX_EXCERPT_CHARS)
+  };
+}
+var MAX_EXCERPT_CHARS = 200;
+function toReportPayload(report) {
+  return {
+    source: report.source,
+    name: report.name,
+    status: report.status,
+    count: report.count,
+    reported_total: report.reportedTotal,
+    reported_total_means: report.reportedTotalMeans,
+    skipped: report.skipped,
+    cached: report.cached,
+    error: report.error ?? null
+  };
+}
+function reportNotes(reports) {
+  const notes = [];
+  const answered = reports.filter((report) => report.status === "answered");
+  const failed = reports.filter((report) => report.status === "failed");
+  for (const report of failed) {
+    const consolation = answered.length > 0 ? `This answer holds what the other sources found, and says nothing about what ${report.name} holds.` : "Nothing here is evidence about what it holds.";
+    notes.push(
+      `${report.name} did not answer (${report.error?.code}): ${report.error?.message} ${consolation}`
+    );
+  }
+  for (const report of answered) {
+    if (report.count === 0) {
+      notes.push(
+        `${report.name} answered and offered no row for this wording. That is a statement about the wording as much as about the corpus: try the dish's name in another language, or a main ingredient.`
+      );
+    }
+    if (report.skipped > 0) {
+      notes.push(
+        `${report.name} sent ${report.skipped} row(s) in a shape this server could not read, and they were left out.`
+      );
+    }
+    if (report.reportedTotal !== null && report.reportedTotalMeans !== null) {
+      notes.push(`${report.name} reported ${report.reportedTotal}: ${report.reportedTotalMeans}.`);
+    } else {
+      notes.push(
+        `${report.name} states no total and offers no second page, so a short list here is not evidence that little exists.`
+      );
+    }
+  }
+  if (answered.some((report) => report.mixesReferencePages && report.count > 0)) {
+    const mixing = answered.filter((report) => report.mixesReferencePages && report.count > 0);
+    notes.push(
+      `${mixing.map((report) => report.name).join(" and ")} files pages about an ingredient beside recipes using it, so a row here can be a page about an ingredient rather than a recipe. get_recipe says when a page carries no ingredient list.`
+    );
+  }
+  if (answered.length > 1) {
+    notes.push(
+      "Each count above measures something different, and they are never added together into one total."
+    );
+  }
+  if (reports.some((report) => report.cached)) {
+    notes.push("Part of this answer came from this server's short-lived in-memory cache.");
+  }
+  return notes;
+}
+var SERVER_MARKERS = /^(\s*)(Note|Sources?|Hint|Ingredients|Steps|What differs)(\s*:)/gim;
+function quoteForeign(value) {
+  return value.replace(/[\r\n\u2028\u2029\u0085]+/g, " ").replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").replace(/!\[/g, "!\\[").replace(/\s{2,}/g, " ").trim().replace(SERVER_MARKERS, " $1$2$3");
+}
+var LOAD_BEARING = /did not answer|could not be read|no longer holds its share|Published under|licen[cs]e|https?:\/\/|rather than a comparison|states no number of servings|no ingredient list|offered no row/i;
+var NOTE_BUDGET = Math.round(MAX_TEXT_CHARS * 0.55);
+function buildTrailer(options) {
+  const credit = options.credit ?? "Source: this server called none.";
+  const kept = [...new Set(options.notes ?? [])];
+  while (kept.length > 0 && kept.join("\n").length > NOTE_BUDGET) {
+    let victim = kept.length - 1;
+    for (let index = kept.length - 1; index >= 0; index -= 1) {
+      if (!LOAD_BEARING.test(kept[index])) {
+        victim = index;
+        break;
+      }
+    }
+    kept.splice(victim, 1);
+  }
+  return [...kept.map((note) => `Note: ${note}`), credit].join("\n");
+}
+function ok(structured, body, options = {}) {
+  const trailer = buildTrailer(options);
+  const cut = "\n\n[shortened; the full result is in the structured output]";
+  const room = MAX_TEXT_CHARS - `
+
+${trailer}`.length;
+  const text2 = body.length <= room ? `${body}
+
+${trailer}` : `${truncate(body, Math.max(0, room - cut.length))}${cut}
+
+${trailer}`;
+  return { content: [{ type: "text", text: text2 }], structuredContent: structured };
+}
+function toToolError(error) {
+  const known = error instanceof RecipesError ? error : new RecipesError("network_error", error instanceof Error ? error.message : String(error));
+  const lines = [`[${known.code}] ${quoteForeign(known.message)}`];
+  if (known.details.hint) lines.push(`Hint: ${quoteForeign(known.details.hint)}`);
+  return { content: [{ type: "text", text: lines.join("\n") }], isError: true };
+}
+function roomForBody(options = {}) {
+  return Math.max(200, MAX_TEXT_CHARS - buildTrailer(options).length - 60);
+}
+function truncate(text2, maxChars) {
+  if (text2.length <= maxChars) return text2;
+  return `${text2.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+}
+function renderRows(rows) {
+  return rows.map((row, index) => {
+    const head = `${index + 1}. ${quoteForeign(row.title)} \xB7 ${quoteForeign(row.source_name)} \xB7 id: ${row.id}`;
+    return `${head}
+   ${quoteForeign(row.url)}`;
+  }).join("\n");
+}
+function creditLine(contributors) {
+  if (contributors.length === 0) return "No source contributed to this answer.";
+  const names2 = contributors.map(
+    (entry) => entry.url ? `${entry.attribution} \u2014 ${quoteForeign(entry.url)}` : entry.attribution
+  );
+  return names2.join("\n");
+}
+
+// src/tools/recipeView.ts
+var yieldSchema = z2.object({
+  original_count: z2.number().nullable().describe("Servings the page states as a number. Null when it states none."),
+  original_max: z2.number().nullable().describe("The upper end when the page states a span, as in '4 \xE0 6 personnes'."),
+  original_text: z2.string().nullable().describe(
+    "The yield in the page's own words. '4 \xE0 6 personnes' and '4 personnes' are different claims, so the wording is kept."
+  ),
+  requested: z2.number().int().nullable().describe("Servings asked for, when any were."),
+  unit: z2.string().nullable().describe("What the yield counts when it counts something other than people, such as 'balls'."),
+  factor: z2.number().nullable().describe("What the quantities were multiplied by. Null when nothing was rescaled.")
+});
+var ratingSchema = z2.object({
+  value: z2.number(),
+  count: z2.number().int().nullable().describe("How many readers rated it, when the source says."),
+  max: z2.number().nullable().describe("The top of the scale. A rating read without its scale means nothing.")
+});
+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."),
+  title: z2.string(),
+  url: z2.string(),
+  image_url: z2.string().nullable(),
+  yield: yieldSchema,
+  ingredients: z2.array(ingredientSchema),
+  steps: z2.array(z2.string()),
+  prep_minutes: z2.number().int().nullable(),
+  cook_minutes: z2.number().int().nullable(),
+  total_minutes: z2.number().int().nullable(),
+  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."),
+  nutrition: z2.record(z2.string(), z2.string()).nullable().describe("The panel as published, key by key. Figures the page omits are absent, never zero."),
+  equipment: z2.array(z2.string()),
+  tips: z2.array(z2.string()),
+  license: z2.object({ title: z2.string(), url: z2.string() }).nullable().describe("Terms the page is published under, when the source states them."),
+  attribution: z2.string().describe("Show this, with the url, when repeating anything from here."),
+  sections_returned: z2.array(z2.string()).describe("The sections this answer carries. Anything outside this list was not looked at."),
+  sections_omitted: z2.array(z2.string()).describe(
+    "Sections nobody asked for. A field belonging to one of these is empty because it was not requested, never because the page states nothing."
+  ),
+  scaling_summary: z2.object({
+    scaled_count: z2.number().int(),
+    rounded_count: z2.number().int(),
+    unscaled_count: z2.number().int()
+  })
+});
+var SECTIONS = [
+  "ingredients",
+  "steps",
+  "times",
+  "nutrition",
+  "tips",
+  "equipment"
+];
+function resolveFactor(recipe, servings) {
+  if (servings === null) return { factor: null, notes: [] };
+  if (recipe.yieldCount === null || recipe.yieldCount <= 0) {
+    return {
+      factor: null,
+      notes: [
+        `${recipe.sourceName} states no number of servings for this recipe, so the quantities are as published. Use scale_ingredients with a factor you choose if you know what it serves.`
+      ]
+    };
+  }
+  const factor = servings / recipe.yieldCount;
+  const notes = [];
+  if (factor === 1) {
+    return {
+      factor: 1,
+      notes: [`The page already yields ${recipe.yieldCount}, so nothing was multiplied.`]
+    };
+  }
+  if (recipe.yieldMax !== null && recipe.yieldMax > recipe.yieldCount) {
+    notes.push(
+      `The page states a span rather than a number: ${quoteForeign(recipe.yieldText ?? "")}. The factor was taken from the lower end, so ${servings} is what this makes at that end. Taken from ${recipe.yieldMax} it would be ${round(servings / recipe.yieldMax)} instead.`
+    );
+  }
+  const unit = recipe.yieldUnit;
+  if (unit && !/personne|people|serving|portion|part\b/i.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)}.`
+    );
+  }
+  return { factor, notes };
+}
+function round(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function buildRecipeView(recipe, options) {
+  const { factor, notes: yieldNotes } = resolveFactor(recipe, options.servings);
+  const wants = (section) => options.sections.includes(section);
+  const ingredients = factor === null || factor === 1 ? passthroughIngredients(recipe.ingredients, recipe.language) : scaleIngredients(recipe.ingredients, { factor, language: recipe.language });
+  const notes = [...yieldNotes];
+  if (recipe.ingredients.length === 0) {
+    notes.push(
+      `${recipe.sourceName} publishes no ingredient list on this page. It is likely a page about the dish rather than a recipe for it, so there is nothing here to scale. Search again and pick another row.`
+    );
+  }
+  const rounded = ingredients.filter((entry) => entry.scaling === "rounded");
+  const unscaled = ingredients.filter((entry) => entry.scaling === "unscaled");
+  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.`
+    );
+  }
+  if (unscaled.length > 0 && factor !== null && factor !== 1) {
+    notes.push(
+      `${unscaled.length} line(s) carry no quantity to multiply and are repeated as published.`
+    );
+  }
+  if (recipe.license) {
+    notes.push(
+      `Published under ${quoteForeign(recipe.license.title)}: ${quoteForeign(recipe.license.url)}`
+    );
+  }
+  const omitted = SECTIONS.filter((section) => !wants(section));
+  if (options.announceSections !== false && omitted.length > 0) {
+    notes.push(
+      `Not requested, so not returned: ${omitted.join(", ")}. Name them in 'sections' to see them.`
+    );
+  }
+  const steps = wants("steps") ? recipe.steps : [];
+  const shownSteps = steps.slice(0, options.maxSteps ?? steps.length).map((step) => truncate(step, options.maxStepChars ?? step.length));
+  if (steps.length > shownSteps.length) {
+    notes.push(
+      `The method runs to ${steps.length} steps and ${shownSteps.length} are here. Raise 'max_steps' for the rest.`
+    );
+  }
+  const payload = {
+    id: recipe.id,
+    source: recipe.source,
+    source_name: recipe.sourceName,
+    language: recipe.language,
+    title: recipe.title,
+    url: recipe.url,
+    image_url: recipe.imageUrl,
+    yield: {
+      original_count: recipe.yieldCount,
+      original_max: recipe.yieldMax,
+      original_text: recipe.yieldText,
+      requested: options.servings,
+      unit: recipe.yieldUnit,
+      factor: factor === null ? null : round(factor)
+    },
+    ingredients: wants("ingredients") ? ingredients.map(toIngredientPayload) : [],
+    steps: shownSteps,
+    prep_minutes: wants("times") ? recipe.prepMinutes : null,
+    cook_minutes: wants("times") ? recipe.cookMinutes : null,
+    total_minutes: wants("times") ? recipe.totalMinutes : null,
+    category: recipe.category,
+    author: recipe.author,
+    rating: recipe.rating,
+    nutrition: wants("nutrition") ? recipe.nutrition : null,
+    equipment: wants("equipment") ? recipe.equipment : [],
+    tips: wants("tips") ? recipe.tips : [],
+    license: recipe.license,
+    attribution: recipe.attribution,
+    sections_returned: [...options.sections],
+    sections_omitted: omitted,
+    scaling_summary: {
+      scaled_count: ingredients.filter((entry) => entry.scaling === "scaled").length,
+      rounded_count: rounded.length,
+      unscaled_count: unscaled.length
+    }
+  };
+  if (options.label) {
+    const label = quoteForeign(options.label);
+    return { payload, notes: notes.map((line) => `${label}: ${line}`), ingredients };
+  }
+  return { payload, notes, ingredients };
+}
+function renderYield(payload) {
+  const published = payload.yield.original_text ?? "an amount the page does not state";
+  if (payload.yield.factor === null) return `Yields ${quoteForeign(published)} (as published).`;
+  return `Yields ${quoteForeign(published)} as published, scaled by ${payload.yield.factor} for ${payload.yield.requested}.`;
+}
+
+// src/tools/arguments.ts
+import { z as z3 } from "zod";
+var INVALID_INPUT = "invalid_input";
+function strictInput(shape) {
+  const declared = Object.keys(shape);
+  return z3.strictObject(shape, {
+    error: (issue) => issue.code === "unrecognized_keys" ? unknownArgumentMessage(issue.keys, declared) : void 0
+  });
+}
+function unknownArgumentMessage(keys, declared) {
+  const named = keys.map((key) => {
+    const near = nearestArgument(key, declared);
+    return near ? `'${key}' (did you mean '${near}'?)` : `'${key}'`;
+  }).join(", ");
+  return `[${INVALID_INPUT}] Unknown ${keys.length > 1 ? "arguments" : "argument"} ${named}. This tool takes: ${declared.join(", ")}.`;
+}
+function nearestArgument(key, declared) {
+  const flatten = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const flat = flatten(key);
+  if (flat.length === 0) return void 0;
+  const sameName = declared.find((name) => flatten(name) === flat);
+  if (sameName) return sameName;
+  const overlapping = declared.find((name) => {
+    const other = flatten(name);
+    const [shorter, longer] = other.length < flat.length ? [other, flat] : [flat, other];
+    return shorter.length >= 3 && (longer.startsWith(shorter) || longer.endsWith(shorter));
+  });
+  if (overlapping) return overlapping;
+  let closest;
+  let shortest = Number.POSITIVE_INFINITY;
+  for (const name of declared) {
+    const distance = editDistance(flat, flatten(name));
+    if (distance < shortest) {
+      shortest = distance;
+      closest = name;
+    }
+  }
+  return shortest <= Math.max(1, Math.floor(flat.length / 3)) ? closest : void 0;
+}
+function editDistance(left, right) {
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let row = 1; row <= left.length; row += 1) {
+    const current = [row];
+    for (let column = 1; column <= right.length; column += 1) {
+      const substitution = previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1);
+      current[column] = Math.min(substitution, previous[column] + 1, current[column - 1] + 1);
+    }
+    previous = current;
+  }
+  return previous[right.length];
+}
+
+// src/tools/compareRecipes.ts
+var compareRecipesDescription = [
+  "Take a dish and show how each source writes it, side by side.",
+  "Each source's closest match is read in full, and all of them can be rescaled to the same number of servings so the ingredient lists stand comparison.",
+  "The answer states what differs and leaves it there: the quantities each asks for, what each measures in, what each yields, and which fields each source publishes at all.",
+  "No version is ranked above another. Some sources carry reader ratings and some have no author and no rating by nature, so there is no score they share.",
+  "When only one source answers, the answer says so and shows that one rather than presenting part of a comparison as the whole of it."
+].join(" ");
+var compareRecipesInput = strictInput({
+  dish: z4.string().min(1).max(200).describe("The dish to compare, in any of the languages the sources publish in."),
+  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.")
+});
+var compareRecipesOutput = z4.object({
+  dish: z4.string(),
+  versions: z4.array(recipeSchema),
+  differences: z4.array(z4.string()).describe("What differs between the versions, stated as fact. No version is ranked."),
+  per_source: z4.array(reportSchema),
+  notes: z4.array(z4.string())
+});
+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[names2.length - 1]}`;
+}
+function describeDifferences(recipes, payloads) {
+  if (recipes.length < 2) return [];
+  const differences = [];
+  const nameOf = (recipe) => recipe.sourceName;
+  const yields = payloads.map((payload) => payload.yield.original_text ?? "no stated amount");
+  if (new Set(yields).size > 1) {
+    differences.push(
+      `${payloads.map((payload, index) => `${payload.source_name} yields ${quoteForeign(yields[index])}`).join("; ")}.`
+    );
+  }
+  const counts = payloads.map((payload) => payload.ingredients.length);
+  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("; ")}.`
+    );
+  }
+  const timed = recipes.filter((recipe) => recipe.totalMinutes !== null);
+  const untimed = recipes.filter((recipe) => recipe.totalMinutes === null);
+  if (timed.length > 0 && new Set(timed.map((recipe) => recipe.totalMinutes)).size > 1) {
+    differences.push(
+      `${timed.map((recipe) => `${nameOf(recipe)} states ${recipe.totalMinutes} minutes`).join("; ")}.`
+    );
+  }
+  if (timed.length > 0 && untimed.length > 0) {
+    differences.push(
+      `${listNames(untimed.map(nameOf))} states no time for this recipe, so there is nothing there to compare against.`
+    );
+  }
+  const rated = recipes.filter((recipe) => recipe.rating !== null);
+  if (rated.length > 0 && rated.length < recipes.length) {
+    differences.push(
+      `Only ${listNames(rated.map(nameOf))} carries 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.`
+    );
+  }
+  const licensed = recipes.filter((recipe) => recipe.license !== null);
+  for (const recipe of licensed) {
+    differences.push(
+      `${nameOf(recipe)} publishes under ${quoteForeign(recipe.license.title)}, which asks for attribution.`
+    );
+  }
+  const silent = recipes.filter((recipe) => recipe.license === null);
+  if (silent.length > 0 && licensed.length > 0) {
+    differences.push(
+      `${listNames(silent.map(nameOf))} states 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 best = /* @__PURE__ */ new Map();
+    for (const row of merged.rows) {
+      if (!best.has(row.source)) best.set(row.source, row.id);
+    }
+    const offered = [...best.entries()];
+    const reads = await Promise.allSettled(offered.map(([, id]) => client.getRecipe(id)));
+    const recipes = [];
+    const unread = /* @__PURE__ */ new Map();
+    reads.forEach((read, index) => {
+      const source = offered[index][0];
+      if (read.status === "fulfilled") {
+        recipes.push(read.value.recipe);
+        return;
+      }
+      const reason = read.reason;
+      unread.set(source, `${reason?.code ?? "network_error"}: ${reason?.message ?? "unknown"}`);
+    });
+    const views = recipes.map(
+      (recipe) => buildRecipeView(recipe, {
+        servings: args.servings ?? null,
+        sections: args.sections,
+        maxSteps: args.max_steps,
+        maxStepChars: args.max_step_chars,
+        label: recipe.sourceName,
+        // The choice of sections belongs to the call rather than to a version,
+        // so it is said once below instead of once per recipe.
+        announceSections: false
+      })
+    );
+    const payloads = views.map((view) => view.payload);
+    const notes = reportNotes(merged.reports);
+    for (const view of views) notes.push(...view.notes);
+    const omitted = SECTIONS.filter((section) => !args.sections.includes(section));
+    if (omitted.length > 0) {
+      notes.push(
+        `Not requested, so not returned on any version: ${omitted.join(", ")}. Name them in 'sections' to see them.`
+      );
+    }
+    for (const report of merged.reports) {
+      if (recipes.some((recipe) => recipe.source === report.source)) continue;
+      const failedRead = unread.get(report.source);
+      if (report.status === "failed") {
+        notes.push(
+          `${report.name} is missing from this comparison because its search did not answer, not because it holds nothing.`
+        );
+      } else if (failedRead) {
+        notes.push(
+          `${report.name} offered a recipe and it could not be read (${quoteForeign(failedRead)}), so its version is missing rather than absent.`
+        );
+      } else {
+        notes.push(
+          `${report.name} answered and offered nothing close enough to "${quoteForeign(args.dish)}" to compare.`
+        );
+      }
+    }
+    if (payloads.length === 1) {
+      notes.push(
+        "This is one version rather than a comparison. Read it as what that one source publishes."
+      );
+    }
+    const differences = describeDifferences(recipes, payloads);
+    if (payloads.length > 1) {
+      notes.push(
+        "Quantities are shown in the units each source published. Nothing was converted between measuring systems, so a gram in one version and a cup in another are two ways of writing a recipe rather than one quantity restated."
+      );
+    }
+    const credit = creditLine(
+      payloads.map((payload) => ({ attribution: payload.attribution, url: payload.url }))
+    );
+    const shownDifferences = differences.slice(0, TEXT_DIFFERENCE_LINES);
+    const moreDifferences = differences.length - shownDifferences.length;
+    const differencesBlock = differences.length > 0 ? `What differs:
+${shownDifferences.map((line) => `- ${line}`).join("\n")}${moreDifferences > 0 ? `
+- \u2026 and ${moreDifferences} more, in full in the structured output` : ""}
+
+` : "";
+    const share = payloads.length === 0 ? 0 : (roomForBody({ notes, credit }) - differencesBlock.length) / payloads.length;
+    const versionBlocks = payloads.map((payload) => {
+      const head = [
+        `${quoteForeign(payload.source_name)}: ${quoteForeign(payload.title)}`,
+        `  ${quoteForeign(payload.url)}`,
+        `  yields ${quoteForeign(payload.yield.original_text ?? "an unstated amount")}${payload.yield.factor === null ? "" : `, scaled by ${payload.yield.factor}`}`
+      ];
+      const lines = [...head];
+      let used = head.join("\n").length;
+      let shown = 0;
+      for (const entry of payload.ingredients.slice(0, TEXT_INGREDIENT_LINES)) {
+        const line = `  - ${quoteForeign(entry.text)}`;
+        if (used + line.length > share) break;
+        lines.push(line);
+        used += line.length + 1;
+        shown += 1;
+      }
+      const hidden = payload.ingredients.length - shown;
+      if (hidden > 0) lines.push(`  \u2026 and ${hidden} more, in full in the structured output`);
+      return lines.join("\n");
+    });
+    const body = payloads.length === 0 ? unread.size > 0 ? `Every version of "${quoteForeign(args.dish)}" that was offered could not be read, so nothing was compared.` : `No source offered a recipe for "${quoteForeign(args.dish)}".` : versionBlocks.join("\n\n");
+    const summary = `${differencesBlock}${body}`;
+    return ok(
+      {
+        dish: args.dish,
+        versions: payloads,
+        differences,
+        per_source: merged.reports.map(toReportPayload),
+        notes
+      },
+      summary,
+      { notes, credit }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/getRecipe.ts
+import { z as z5 } from "zod";
+var getRecipeDescription = [
+  "Read one recipe in full: its ingredients, its steps, what it yields, and whatever times, rating and nutrition its source publishes.",
+  "'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.",
+  "'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 getRecipeInput = strictInput({
+  id: z5.string().min(1).max(500).describe("From search_recipes, such as 'marmiton:44078' or 'cookbook:Cookbook:Carbonara'."),
+  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_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,
+  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())
+});
+async function runGetRecipe(client, args) {
+  try {
+    const { recipe, cached, read } = await client.getRecipe(args.id);
+    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 payload = view.payload;
+    const lines = [
+      `${quoteForeign(payload.title)} \xB7 ${quoteForeign(payload.source_name)}`,
+      quoteForeign(payload.url),
+      renderYield(payload)
+    ];
+    if (payload.ingredients.length > 0) {
+      lines.push(
+        "",
+        "Ingredients:",
+        ...payload.ingredients.map(
+          (entry) => entry.scaling === "unscaled" ? `- ${quoteForeign(entry.text)} (no quantity)` : `- ${quoteForeign(entry.text)}`
+        )
+      );
+    }
+    if (payload.steps.length > 0) {
+      lines.push(
+        "",
+        "Steps:",
+        ...payload.steps.map((step, index) => `${index + 1}. ${quoteForeign(step)}`)
+      );
+    }
+    return ok({ recipe: payload, id_read_as: read.inferred, notes }, lines.join("\n"), {
+      notes,
+      credit: creditLine([{ attribution: payload.attribution, url: payload.url }])
+    });
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// 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.",
+  "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.",
+  "No quantity is converted between measuring systems: grams stay grams and cups stay cups, because a conversion changes what the recipe said."
+].join(" ");
+var scaleIngredientsInput = strictInput({
+  ingredients: z6.array(z6.string().max(500)).min(1).max(200).describe(
+    "The lines as written, one ingredient each, such as '200 g de farine' or '3 eggs'. One line, not a whole recipe."
+  ),
+  factor: z6.number().gt(0).max(1e3).optional().describe(
+    "What to multiply by. Give exactly one of: 'factor', or both 'from_servings' and 'to_servings'."
+  ),
+  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."
+  )
+});
+var scaleIngredientsOutput = z6.object({
+  factor: z6.number().describe("What every quantity was multiplied by."),
+  language: z6.string().describe("How the lines were read."),
+  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."),
+  notes: z6.array(z6.string())
+});
+function resolveFactor2(args) {
+  const hasPair = args.from_servings !== void 0 && args.to_servings !== void 0;
+  if (args.factor !== void 0 && hasPair) {
+    throw invalidInput(
+      "Give either 'factor' or the pair of serving counts, not both.",
+      `factor=${args.factor} and ${args.from_servings}\u2192${args.to_servings} would be two different multipliers.`
+    );
+  }
+  if (args.factor !== void 0) return args.factor;
+  if (hasPair) return args.to_servings / args.from_servings;
+  if (args.from_servings !== void 0 || args.to_servings !== void 0) {
+    throw invalidInput(
+      "Serving counts come in pairs: give both 'from_servings' and 'to_servings'.",
+      "Or give 'factor' on its own."
+    );
+  }
+  throw invalidInput(
+    "Nothing said how much to multiply by.",
+    "Give 'factor', or both 'from_servings' and 'to_servings'."
+  );
+}
+function runScaleIngredients(args) {
+  try {
+    const factor = resolveFactor2(args);
+    const scaled = scaleIngredients(args.ingredients, {
+      factor,
+      language: args.language
+    });
+    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
+    };
+    const notes = [];
+    if (counts.rounded_count > 0) {
+      notes.push(
+        `${counts.rounded_count} line(s) did not land on the exact product; each says in its own note what happened to it.`
+      );
+    }
+    if (counts.unscaled_count > 0) {
+      notes.push(
+        `${counts.unscaled_count} line(s) carry no quantity to multiply and are repeated as given.`
+      );
+    }
+    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."
+        );
+      }
+    }
+    if (scaled.some((entry) => entry.note?.includes("approximate measure"))) {
+      notes.push(
+        "A pinch, a handful and their kind were multiplied by their count. The size of one stays whatever the cook's hand gives it, and none of them was turned into grams or spoons."
+      );
+    }
+    const body = scaled.map((entry, index) => `${index + 1}. ${quoteForeign(entry.text)}`).join("\n");
+    return ok(
+      {
+        factor: Math.round(factor * 1e3) / 1e3,
+        language: args.language,
+        ingredients: scaled.map(toIngredientPayload),
+        ...counts,
+        notes
+      },
+      `Scaled by ${Math.round(factor * 1e3) / 1e3}:
+${body}`,
+      { notes, credit: "Source: the list you supplied. Scaled offline; nothing was fetched." }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/tools/searchRecipes.ts
+import { z as z7 } from "zod";
+var searchRecipesDescription = [
+  "Search every recipe source this server reads, at the same time, for a dish or an ingredient, and get one merged list.",
+  "Each row carries the id get_recipe takes, and that id names the source it came from, so nothing has to be guessed afterwards.",
+  "The sources are written in different languages and count their own results differently, so 'per_source' says what each one answered, what its own number means, and names any that failed. A short list is never evidence of what exists.",
+  "Some sources keep recipes and reference pages together, so a row can be a page about an ingredient rather than a recipe using it. Only get_recipe can tell them apart, and it says when a page carries no ingredient list.",
+  "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.",
+  "Rows are interleaved one source at a time rather than ranked, because the sources share no score that could order them against each other."
+].join(" ");
+var searchRecipesInput = strictInput({
+  query: z7.string().min(1).max(200).describe("A dish or an ingredient, in any of the languages the sources publish in."),
+  limit_per_source: z7.number().int().min(1).max(25).default(5).describe("Rows to take from each source, so one source cannot fill the whole list."),
+  sources: z7.array(z7.string()).optional().describe(
+    "Sources to ask, by id. Left out, they are all asked, which is the point of this tool. The ids are the ones 'per_source' reports."
+  )
+});
+var searchRecipesOutput = z7.object({
+  query: z7.string(),
+  results: z7.array(rowSchema),
+  result_count: z7.number().int().describe("Rows in this answer, across every source."),
+  per_source: z7.array(reportSchema),
+  order: z7.string().describe("How the list was built, in words."),
+  notes: z7.array(z7.string())
+});
+var WORDS_BEFORE_SAYING_SO = 4;
+async function runSearchRecipes(client, args) {
+  try {
+    const merged = await client.searchRecipes(
+      args.query,
+      args.limit_per_source,
+      args.sources
+    );
+    const results = merged.rows.map(toRowPayload);
+    const notes = reportNotes(merged.reports);
+    const answered = merged.reports.filter((report) => report.status === "answered");
+    const contributed = merged.reports.filter((report) => report.count > 0);
+    const order = contributed.length > 1 ? "One row from each source in turn, in the order each source returned them. No score orders them against each other." : contributed.length === 1 ? `Every row came from ${contributed[0].name}, in the order it returned them.` : "No source contributed a row.";
+    if (args.query.trim().split(/\s+/).length > WORDS_BEFORE_SAYING_SO) {
+      notes.push(
+        "This query went to each source as free text and no filter was applied to it. Words like 'vegan' or 'under 300 calories' help only where a source's own index happens to match them, so read the rows rather than assuming they meet every condition."
+      );
+    }
+    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."
+      );
+    }
+    const body = results.length > 0 ? `${results.length} recipes for "${args.query}":
+${renderRows(results)}` : answered.length === 0 ? `No source answered for "${args.query}", so nothing here says whether such a recipe exists.` : `Nothing came back for "${args.query}".`;
+    return ok(
+      {
+        query: args.query,
+        results,
+        result_count: results.length,
+        per_source: merged.reports.map(toReportPayload),
+        order,
+        notes
+      },
+      body,
+      {
+        notes,
+        credit: creditLine(
+          contributed.map((report) => ({ attribution: `Source: ${report.name}` }))
+        )
+      }
+    );
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/server.ts
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function buildInstructions(sources) {
+  const named = sources.map((source) => `${source.name} (${source.language})`).join(", ");
+  return [
+    `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.",
+    "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.",
+    "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.",
+    "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" }
+]);
+function createServer(options = {}) {
+  const config = options.config ?? loadConfig();
+  const logger = options.logger ?? createLogger(config.logLevel);
+  const client = options.client ?? new RecipesClient({ config, logger });
+  const server = new McpServer(
+    { name: "mcp-recipes", version: PKG_VERSION },
+    { instructions: buildInstructions(client.profiles) }
+  );
+  server.registerTool(
+    "search_recipes",
+    {
+      title: "Search every recipe source at once",
+      description: searchRecipesDescription,
+      inputSchema: searchRecipesInput,
+      outputSchema: searchRecipesOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runSearchRecipes(client, args)
+  );
+  server.registerTool(
+    "get_recipe",
+    {
+      title: "Read one recipe, optionally rescaled",
+      description: getRecipeDescription,
+      inputSchema: getRecipeInput,
+      outputSchema: getRecipeOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runGetRecipe(client, args)
+  );
+  server.registerTool(
+    "scale_ingredients",
+    {
+      title: "Scale an ingredient list, in either language",
+      description: scaleIngredientsDescription,
+      inputSchema: scaleIngredientsInput,
+      outputSchema: scaleIngredientsOutput,
+      annotations: {
+        ...READ_ONLY,
+        // Nothing is fetched, so this tool reaches nothing outside itself.
+        openWorldHint: false
+      }
+    },
+    async (args) => runScaleIngredients(args)
+  );
+  server.registerTool(
+    "compare_recipes",
+    {
+      title: "One dish, as each source writes it",
+      description: compareRecipesDescription,
+      inputSchema: compareRecipesInput,
+      outputSchema: compareRecipesOutput,
+      annotations: READ_ONLY
+    },
+    async (args) => runCompareRecipes(client, args)
+  );
+  logger.info(
+    `ready: ${client.profiles.length} sources (${client.profiles.map((source) => source.id).join(", ")}), user-agent="${client.userAgent}", ${client.intervalMs}ms between requests to one source`
+  );
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = async () => {
+    await server.close().catch(() => void 0);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`[mcp-recipes] fatal: ${message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map