mcp-marmiton 1.5.0 → 1.6.0

package/README.md

@@ -81,9 +81,35 @@ landed somewhere the arithmetic did not put it, a half egg taken to a whole one
 or 133.4 g written as 135 g.
 
 Two rules are enforced. Scaling a recipe **down never asks for more** than the
-original: half a sachet at factor 0.667 becomes a third of a sachet, never a whole
-one. And scaling never **silently drops** an ingredient by rounding it to zero,
-which is why small amounts come back as fractions.
+original: half a sachet at factor 0.667 stays half a sachet, never a whole one.
+And scaling never **silently drops** an ingredient by rounding it to zero, which
+is why small amounts come back as fractions.
+
+**A counted thing is divided by what it holds, not by what holds it.** A boîte de
+tomates is poured and the rest kept, a sachet de sucre vanillé is split by eye, a
+feuille de gélatine is cut with scissors, a branche de thym is broken in two: all
+of those land on a half. Half an oeuf would have to be
+beaten and weighed, which is not an amount a recipe asks for, so a count of oeufs,
+jaunes or blancs d'oeufs lands on a whole number. A few things are decided by what
+they are: a clou de girofle and a zeste are counted whole, a pot and a bouteille
+hold enough for a quarter to be a portion, a gousse and a tranche are cut off
+something larger and take a corner off in the same gesture, a blanc de poulet is
+meat and halves, and a douzaine states a number of things rather than a measure
+of them, so `2 douzaines d'escargots` at three quarters comes back as
+`18 escargots`.
+
+**A thing counted on its own is divided by the size of one against what a recipe
+puts in.** Une crevette, une moule, une noisette, un grain de poivre, une baie de
+genièvre, un anis étoilé is already a portion: a recipe counts twelve of them
+and a smaller recipe puts one fewer in the pan, so they land on a whole number.
+Un gigot, une baguette, un camembert, un ananas, un oignon, une pastèque, une
+pintade, un poulet, un poireau sits at
+the other end of that comparison, asked for by the one or the two and shared out
+with a knife, so they go as far as the quarter. A cut carved off one of them
+stops at the half, une cuisse and une aile being the portion the knife already
+produced. Un jus stops at the half: half
+the jus of a citron is taken by squeezing half the fruit, and a quarter of one
+has to be poured out and measured back.
 
 Approximate measures are quantities too. A pinch, a handful, a bouchon or a
 ramequin has the size the cook gives it, and the recipe's proportion lives in how
@@ -107,8 +133,10 @@ the line as published.
 Each ingredient also carries `adjusted`, which says whether rounding moved the
 number away from the exact product.
 
-Below a quarter there is nothing a kitchen can measure, so the amount is clamped
-up and **the line stops holding its share of the recipe**. Half a sachet of
+A shrinking line keeps the smallest share still worth measuring: a knife takes an
+oignon to a quarter, a boîte or a sachet goes to a half, an oeuf stops at one.
+Under that floor the amount is clamped up and **the line stops holding its share
+of the recipe**. Half a sachet of
 baking powder against three pots of flour comes out four times too strong that
 way, so the ingredient and the response both say it happened rather than leaving
 you to find out in the oven.
@@ -293,10 +321,24 @@ ailleurs que là où le calcul la mettait, un demi-œuf ramené à un œuf entie
 133,4 g écrits 135 g.
 
 Deux règles sont garanties. Réduire une recette **ne demande jamais davantage** que
-l'originale : un demi-sachet au facteur 0,667 devient un tiers de sachet, jamais un
+l'originale : un demi-sachet au facteur 0,667 reste un demi-sachet, jamais un
 sachet entier. Et l'adaptation ne **supprime jamais** un ingrédient en l'arrondissant
 à zéro, d'où les fractions pour les petites quantités.
 
+**Un dénombrable se divise selon son contenu, pas selon son emballage.** Une boîte
+de tomates se verse et le reste se garde, un sachet de sucre vanillé se partage à
+l'œil, une feuille de gélatine se coupe aux ciseaux, une branche de thym se casse
+en deux : tous tombent sur une demie. Un demi-œuf, lui,
+demanderait de le battre et de le peser, ce qu'aucune recette ne demande : un
+nombre d'œufs, de jaunes ou de blancs d'œufs tombe sur un entier. Quelques cas se
+décident sur la nature de la chose : un clou de girofle et un zeste se comptent
+entiers, un pot et une bouteille en contiennent assez pour qu'un quart soit une
+portion, une gousse et une tranche sont déjà taillées dans plus grand et la
+planche leur reprend un coin du même geste, un blanc de poulet est une viande et
+se coupe en deux, et une douzaine
+énonce un nombre de choses plutôt qu'une mesure, si bien que
+« 2 douzaines d'escargots » réduites d'un quart reviennent en « 18 escargots ».
+
 Les mesures approximatives sont des quantités elles aussi. Une pincée, une
 poignée, un bouchon ou un ramequin ont la taille que le cuisinier leur donne,
 et la proportion de la recette tient au nombre demandé : ce nombre est donc
@@ -321,8 +363,10 @@ publiée.
 Chaque ingrédient porte aussi `adjusted`, qui dit si l'arrondi a déplacé le
 nombre par rapport au produit exact.
 
-Sous un quart, il n'y a plus rien qu'une cuisine puisse mesurer : la quantité est
-alors remontée et **la ligne cesse de tenir sa part de la recette**. Un demi-sachet
+Une ligne qui rétrécit garde la plus petite part qui vaille encore la peine : le
+couteau mène un oignon au quart, une boîte ou un sachet s'arrêtent à la demie, un
+œuf s'arrête à l'unité. Sous ce plancher, la quantité est remontée et **la ligne
+cesse de tenir sa part de la recette**. Un demi-sachet
 de levure face à trois pots de farine ressort ainsi quatre fois trop dosé, donc
 l'ingrédient et la réponse le disent, plutôt que de vous le laisser découvrir au
 four.

package/dist/index.js

@@ -4,7 +4,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/version.ts
-var PKG_VERSION = "1.5.0";
+var PKG_VERSION = "1.6.0";
 var REPO_URL = "https://github.com/smeet666/mcp-marmiton";
 
 // src/config.ts
@@ -111,7 +111,7 @@ function createLogger(level) {
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/marmiton/cache.ts
 var TtlLruCache = class {
@@ -681,7 +681,7 @@ var MarmitonClient = class {
 };
 
 // src/tools/getRecipe.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/recipe/units.ts
 var UNITS = {
@@ -868,6 +868,14 @@ function readableUnitStep(unit, amount) {
   }
   return { unit, ratio: 1 };
 }
+function unitDivisibility(unit) {
+  if (unit.kind === "vague") return "whole";
+  return QUARTERED_MEASURE.test(unit.canonical) ? "quarter" : "half";
+}
+var QUARTERED_MEASURE = /\b(pots?|bouteilles?|gousses?|tranches?)\b/;
+function isSpoonMeasure(unit) {
+  return /^(cuillère à soupe|cuillère à café|verre|tasse|bol)$/.test(unit.canonical);
+}
 function formatUnit(unit, amount) {
   if (unit.symbol) return unit.canonical;
   if (amount < 2) return unit.canonical;
@@ -927,7 +935,7 @@ function parseLeadingArticle(text) {
   const match = /^\s*(un|une|quelques)\b\s*/i.exec(text);
   if (!match) return null;
   const rest = text.slice(match[0].length);
-  if (!matchLeadingUnit(rest, true)) return null;
+  if (!matchLeadingUnit(rest, true) && !readCountMultiplier(rest)) return null;
   const word = match[1];
   return {
     amount: ARTICLE_AMOUNTS[word.toLowerCase()],
@@ -935,6 +943,17 @@ function parseLeadingArticle(text) {
     word
   };
 }
+var COUNT_MULTIPLIERS = {
+  douzaine: 12,
+  douzaines: 12
+};
+function readCountMultiplier(text) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+", "u").exec(text);
+  if (!match) return null;
+  const times = COUNT_MULTIPLIERS[normalizeUnitKey(match[1])];
+  if (times === void 0) return null;
+  return { times, rest: text.slice(match[0].length) };
+}
 function matchLeadingUnit(text, partitive = false) {
   const normalized = normalizeUnitKey(text);
   for (const key of UNIT_KEYS) {
@@ -974,10 +993,14 @@ function parseIngredient(line) {
       unit: null,
       unitText: null,
       item: text,
-      articleWord: null
+      articleWord: null,
+      countMultiplier: null
     };
   }
   let rest = text.slice(quantity.length).trimStart();
+  const multiplier = readCountMultiplier(rest);
+  if (multiplier) rest = multiplier.rest;
+  const times = multiplier?.times ?? 1;
   const matched = matchLeadingUnit(rest, quantity === article);
   const unit = matched?.unit ?? null;
   const unitText = matched?.unitText ?? null;
@@ -985,13 +1008,14 @@ function parseIngredient(line) {
   const item = rest.replace(/^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i, "").replace(/^(?:une|un)\s+/i, "").trim();
   return {
     original,
-    amount: quantity.amount,
-    amountMax: range?.max ?? null,
+    amount: quantity.amount * times,
+    amountMax: range === null ? null : range.max * times,
     rangeSeparator: range?.separator ?? null,
     unit,
     unitText,
     item,
-    articleWord: quantity === article ? article?.word ?? null : null
+    articleWord: quantity === article ? article?.word ?? null : null,
+    countMultiplier: multiplier?.times ?? null
   };
 }
 function parseLeadingRange(text) {
@@ -1044,8 +1068,64 @@ function roundMeasured(value) {
   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;
+}
+var PORTION_SIZED_ITEM = /\b(crevettes?|gambas|langoustines?|moules?|noisettes?|grains?|genievres?|anis)\b/;
+var QUARTERED_ITEM = /\b(oignons?|echalotes?|pommes? de terre|pommes?|poires?|carottes?|citrons?|oranges?|tomates?|concombres?|courgettes?|aubergines?|courges?|potirons?|choux?|melons?|poivrons?|betteraves?|navets?|panais|poireaux?|bananes?|mangues?|avocats?|pasteques?|gigots?|baguettes?|camemberts?|fromages?|chevres?|chorizos?|reblochons?|buches?|ananas|peches?|abricots?|laits?|poulets?|pintades?|rotis?)\b/;
+var HALVED_CUT = /\b(cuisses?|ailes?|pilons?|escalopes?|magrets?)\b/;
+var HALVED_ITEM = /\bjus\b/;
+var WHOLE_ITEM = /\b(oeufs?|jaunes?|clous?|zestes?)\b/;
+function blancDivisibility(key) {
+  if (!/\bblancs? de? /.test(key)) return null;
+  return /\bblancs? de? oeufs?\b/.test(key) ? "whole" : "half";
+}
+function articleValue(parsed) {
+  return parsed.amount === null ? 0 : parsed.amount / (parsed.countMultiplier ?? 1);
+}
+function divisibilityOf(unit, item) {
+  if (unit) return unitDivisibility(unit);
+  const key = item.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/œ/g, "oe").replace(/['’]/g, " ");
+  const blanc = blancDivisibility(key);
+  if (blanc) return blanc;
+  if (WHOLE_ITEM.test(key)) return "whole";
+  if (PORTION_SIZED_ITEM.test(key)) return "whole";
+  if (HALVED_ITEM.test(key)) return "half";
+  if (HALVED_CUT.test(key)) return "half";
+  if (QUARTERED_MEASURE.test(key)) return "quarter";
+  return QUARTERED_ITEM.test(key) ? "quarter" : "half";
+}
 var EXACT_WITHIN = 0.01;
-function roundCountable(value, allowHalves, ceiling) {
+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, 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: Math.round(closest * 100) / 100, 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(
@@ -1060,7 +1140,7 @@ function roundCountable(value, allowHalves, ceiling) {
       clamped: value < SMALLEST_USABLE_FRACTION
     };
   }
-  return { value: allowHalves ? roundTo(value, 0.5) : Math.round(value), clamped: false };
+  return { value: roundTo(value, 0.5), clamped: false };
 }
 function scaleApproximateCount(source, raw, factor) {
   if (raw <= 0) return 0;
@@ -1094,15 +1174,15 @@ function agreeWithAmount(item, amount) {
   const wantsPlural = amount >= 2;
   const isPlural = /s$|eaux$|aux$/i.test(head);
   if (wantsPlural && !isPlural) {
-    if (/[sxz]$/i.test(head)) return item;
-    if (/eau$/i.test(head)) words[0] = `${head}x`;
+    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 (/[aiou]s$/i.test(head)) return item;
-    else words[0] = head.slice(0, -1);
+    else if (INVARIABLE_NOUN.has(foldWord(head))) {
+    } else words[0] = head.slice(0, -1);
   }
   const last = words.length - 1;
   if (last > 0) {
@@ -1111,9 +1191,31 @@ function agreeWithAmount(item, amount) {
   }
   return words.join(" ");
 }
+var INVARIABLE_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",
@@ -1200,9 +1302,8 @@ function scaleIngredient(line, options) {
         clamped: false
       };
     }
-    const allowHalves = /cuillère|verre|tasse|bol/.test(parsed.unit?.canonical ?? "");
     const ceiling = factor < 1 ? source : Number.POSITIVE_INFINITY;
-    const rounded = roundCountable(raw, allowHalves, ceiling);
+    const rounded = parsed.unit && isSpoonMeasure(parsed.unit) ? roundSpoon(raw, ceiling) : roundCountable(raw, divisibilityOf(parsed.unit, parsed.item), ceiling);
     return {
       amount: rounded.value,
       unit: parsed.unit,
@@ -1238,20 +1339,21 @@ function scaleIngredient(line, options) {
     const many = unit ? formatUnit(unit, 2) : "measures";
     const sentences = [];
     if (parsed.articleWord) {
-      sentences.push(`"${parsed.articleWord}" read as ${formatAmount(parsed.amount)}.`);
+      sentences.push(`"${parsed.articleWord}" read as ${formatAmount(articleValue(parsed))}.`);
     }
     sentences.push(
       `${APPROXIMATE_MEASURE_MARKER} the number of ${many} was multiplied, and one ${one} keeps the size the cook gives it.`
     );
     if (adjusted) sentences.push(`Rounded from ${formatAmount(Math.round(low.raw * 100) / 100)}.`);
     result.note = sentences.join(" ");
-  } else if (bounds.some((bound) => bound.clamped)) {
-    result.note = `Clamped up to ${formatAmount(SMALLEST_USABLE_FRACTION)} from ${formatAmount(Math.round(low.raw * 1e3) / 1e3)}, the smallest amount worth measuring. This line no longer holds its share of the recipe.`;
+  } else if (clamped) {
+    const floored = bounds.find((bound) => bound.clamped);
+    result.note = `Clamped up to ${formatAmount(floored.amount)} from ${formatAmount(Math.round(floored.raw * 1e3) / 1e3)}, the smallest amount worth measuring. This line no longer holds its share of the recipe.`;
   } else if (adjusted) {
     result.note = `Rounded from ${formatAmount(Math.round(low.raw * 100) / 100)}.`;
   }
   if (kind !== "vague" && parsed.articleWord) {
-    const read = `"${parsed.articleWord}" read as ${formatAmount(parsed.amount)}.`;
+    const read = `"${parsed.articleWord}" read as ${formatAmount(articleValue(parsed))}.`;
     result.note = result.note ? `${read} ${result.note}` : read;
   }
   return result;
@@ -1277,23 +1379,74 @@ function passthroughIngredients(lines) {
   });
 }
 
-// src/tools/shared.ts
+// src/tools/arguments.ts
 import { z } from "zod";
+var INVALID_INPUT = "invalid_input";
+function strictInput(shape) {
+  const declared = Object.keys(shape);
+  const errorMap = (issue, ctx) => issue.code === z.ZodIssueCode.unrecognized_keys ? { message: unknownArgumentMessage(issue.keys, declared) } : { message: ctx.defaultError };
+  return z.strictObject(shape, { errorMap });
+}
+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 flatten2 = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const flat = flatten2(key);
+  if (flat.length === 0) return void 0;
+  const sameName = declared.find((name) => flatten2(name) === flat);
+  if (sameName) return sameName;
+  const overlapping = declared.find((name) => {
+    const other = flatten2(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, flatten2(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/shared.ts
+import { z as z2 } from "zod";
 var MAX_TEXT_MIRROR_CHARS = 2e3;
-var scaledIngredientSchema = z.object({
-  original: z.string().describe("The ingredient line exactly as Marmiton publishes it."),
-  text: z.string().describe("The line after scaling, identical to 'original' when unscaled."),
-  amount: z.number().nullable().describe(
+var scaledIngredientSchema = z2.object({
+  original: z2.string().describe("The ingredient line exactly as Marmiton publishes it."),
+  text: z2.string().describe("The line after scaling, identical to 'original' when unscaled."),
+  amount: z2.number().nullable().describe(
     "The scaled quantity, expressed in 'unit'. Read the two together: a large result is moved to a bigger unit, so 200 g scaled tenfold reads as 2 kg, and the bare number shrinks while the quantity grows."
   ),
-  unit: z.string().nullable().describe("The unit 'amount' is in, which may differ from the one the recipe used."),
-  scaling: z.enum(["scaled", "rounded", "unscaled"]).describe(
+  unit: z2.string().nullable().describe("The unit 'amount' is in, which may differ from the one the recipe used."),
+  scaling: z2.enum(["scaled", "rounded", "unscaled"]).describe(
     "'scaled' means the arithmetic came out exact, which a count reaches as readily as a mass: one pinch multiplied by six is six pinches. 'rounded' means the value had to be moved to stay usable, to a whole or half unit or to a step a scale can show. 'unscaled' was left alone, because the line carries no quantity."
   ),
-  adjusted: z.boolean().describe(
+  adjusted: z2.boolean().describe(
     "True when rounding moved the value away from the exact product, which is what makes a line 'rounded' rather than 'scaled'."
   ),
-  note: z.string().optional().describe(
+  note: z2.string().optional().describe(
     "Why the line was rounded, clamped or left alone, including when the measure is approximate and only its count was multiplied."
   )
 });
@@ -1333,46 +1486,46 @@ var getRecipeDescription = [
   "Recipes yielding pieces rather than servings are rescaled the same way; check 'yield' to see which.",
   "Always cite 'attribution' when showing a recipe to a user."
 ].join(" ");
-var getRecipeInputShape = {
-  id: z2.string().regex(/^\d+$/, "Recipe ids are digits only.").optional().describe("Marmiton recipe id, as returned by search_recipes. Preferred over 'url'."),
-  url: z2.string().url().optional().describe(
+var getRecipeInput = strictInput({
+  id: z3.string().regex(/^\d+$/, "Recipe ids are digits only.").optional().describe("Marmiton recipe id, as returned by search_recipes. Preferred over 'url'."),
+  url: z3.string().url().optional().describe(
     "Full marmiton.org recipe URL. Only marmiton.org is accepted. Ignored when 'id' is given."
   ),
-  servings: z2.number().positive().max(500).optional().describe(
+  servings: z3.number().positive().max(500).optional().describe(
     "Rescale the ingredients to this many servings. Omit to get the recipe exactly as published."
   )
-};
+});
 var getRecipeOutputShape = {
-  id: z2.string(),
-  title: z2.string(),
-  url: z2.string(),
-  yield: z2.object({
-    original_count: z2.number().nullable(),
-    original_text: z2.string(),
-    requested: z2.number().nullable(),
-    unit: z2.string().nullable().describe("What is being counted: 'personnes', 'pi\xE8ces'."),
-    factor: z2.number().nullable().describe("Multiplier applied to the quantities.")
+  id: z3.string(),
+  title: z3.string(),
+  url: z3.string(),
+  yield: z3.object({
+    original_count: z3.number().nullable(),
+    original_text: z3.string(),
+    requested: z3.number().nullable(),
+    unit: z3.string().nullable().describe("What is being counted: 'personnes', 'pi\xE8ces'."),
+    factor: z3.number().nullable().describe("Multiplier applied to the quantities.")
   }),
-  ingredients: z2.array(scaledIngredientSchema),
-  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(),
-  rating: z2.object({ value: z2.number(), count: z2.number().nullable(), best: z2.number().nullable() }).nullable(),
-  nutrition: z2.object({
-    calories: z2.string().nullable(),
-    protein: z2.string().nullable(),
-    fat: z2.string().nullable(),
-    carbohydrate: z2.string().nullable(),
-    fiber: z2.string().nullable(),
-    sodium: z2.string().nullable(),
-    serving_size: z2.string().nullable()
+  ingredients: z3.array(scaledIngredientSchema),
+  steps: z3.array(z3.string()),
+  prep_minutes: z3.number().int().nullable(),
+  cook_minutes: z3.number().int().nullable(),
+  total_minutes: z3.number().int().nullable(),
+  category: z3.string().nullable(),
+  author: z3.string().nullable(),
+  rating: z3.object({ value: z3.number(), count: z3.number().nullable(), best: z3.number().nullable() }).nullable(),
+  nutrition: z3.object({
+    calories: z3.string().nullable(),
+    protein: z3.string().nullable(),
+    fat: z3.string().nullable(),
+    carbohydrate: z3.string().nullable(),
+    fiber: z3.string().nullable(),
+    sodium: z3.string().nullable(),
+    serving_size: z3.string().nullable()
   }).nullable().describe("Nutrition is given for the recipe as published, not rescaled."),
-  attribution: z2.string(),
-  source: z2.literal("marmiton.org"),
-  notes: z2.array(z2.string())
+  attribution: z3.string(),
+  source: z3.literal("marmiton.org"),
+  notes: z3.array(z3.string())
 };
 async function runGetRecipe(client, args) {
   try {
@@ -1491,32 +1644,34 @@ ${stepLines}` : ""
 }
 
 // src/tools/scaleIngredients.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var scaleIngredientsDescription = [
   "Rescale a list of ingredient lines to a different number of servings, without contacting any website.",
   "Give either 'factor' directly, or 'from_servings' and 'to_servings' and the factor is computed.",
   "Works on any French ingredient list, whatever its source, so it also serves a recipe the user pasted in.",
-  "Quantities in grams or millilitres are multiplied and rounded to readable values; countable things such as",
-  "eggs or spoons are rounded to whole or half units; approximate measures such as a pinch or a handful have",
+  "Quantities in grams or millilitres are multiplied and rounded to readable values; a countable thing lands on",
+  "a half when half of one can be poured, weighed or cut, as a bo\xEEte, a sachet, a feuille de g\xE9latine or a",
+  "cuill\xE8re can, and on a whole one when it cannot, as an oeuf, a jaune or a blanc; approximate measures such",
+  "as a pinch or a handful have",
   "their count multiplied in whole units and stay in their own vocabulary. A line writing an article where a",
   "digit would go, as in 'un bouchon de rhum' or 'une pinc\xE9e de sel', is read as one of that measure. Lines",
   "carrying no quantity are returned untouched and flagged. Prefer this over doing the arithmetic yourself."
 ].join(" ");
-var scaleIngredientsInputShape = {
-  ingredients: z3.array(z3.string().max(300)).min(1).max(100).describe("Ingredient lines, for example ['200 g de farine', '3 oeufs', 'sel']."),
-  factor: z3.number().positive().max(100).optional().describe("Multiplier to apply. Use this or the from/to pair."),
-  from_servings: z3.number().positive().max(500).optional().describe("How many servings the list is written for."),
-  to_servings: z3.number().positive().max(500).optional().describe("How many servings are wanted.")
-};
+var scaleIngredientsInput = strictInput({
+  ingredients: z4.array(z4.string().max(300)).min(1).max(100).describe("Ingredient lines, for example ['200 g de farine', '3 oeufs', 'sel']."),
+  factor: z4.number().positive().max(100).optional().describe("Multiplier to apply. Use this or the from/to pair."),
+  from_servings: z4.number().positive().max(500).optional().describe("How many servings the list is written for."),
+  to_servings: z4.number().positive().max(500).optional().describe("How many servings are wanted.")
+});
 var scaleIngredientsOutputShape = {
-  factor: z3.number(),
-  ingredients: z3.array(scaledIngredientSchema),
-  scaled_count: z3.number().int(),
-  rounded_count: z3.number().int().describe(
+  factor: z4.number(),
+  ingredients: z4.array(scaledIngredientSchema),
+  scaled_count: z4.number().int(),
+  rounded_count: z4.number().int().describe(
     "Lines whose value rounding moved away from the exact product, not lines that could have been rounded."
   ),
-  unscaled_count: z3.number().int(),
-  notes: z3.array(z3.string())
+  unscaled_count: z4.number().int(),
+  notes: z4.array(z4.string())
 };
 function formatFactor(factor) {
   return String(Number(factor.toPrecision(3)));
@@ -1590,7 +1745,7 @@ ${lines}`, notes);
 }
 
 // src/tools/searchRecipes.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var searchRecipesDescription = [
   "Search Marmiton for recipes by free text: a dish, an ingredient, or both, for example 'tarte aux pommes'",
   "or 'poulet curry coco'. Marmiton is a French site, so French terms work best.",
@@ -1598,28 +1753,28 @@ var searchRecipesDescription = [
   "One call returns one page of results. Marmiton's robots.txt disallows paginating search results, so this",
   "server does not, and there is no page parameter: narrow the query instead of asking for more pages."
 ].join(" ");
-var searchRecipesInputShape = {
+var searchRecipesInput = strictInput({
   // Deliberately no min(1): an empty string would be rejected by the schema with
   // a protocol-level validation error, while a whitespace-only one would reach
   // the tool and come back as invalid_input. Letting both through to the same
   // check gives callers one error code for one problem.
-  query: z4.string().max(200).describe("What to search for, in French, for example 'tarte aux pommes'."),
-  limit: z4.number().int().min(1).max(30).default(10).describe("Maximum recipes to return from this page of results.")
-};
+  query: z5.string().max(200).describe("What to search for, in French, for example 'tarte aux pommes'."),
+  limit: z5.number().int().min(1).max(30).default(10).describe("Maximum recipes to return from this page of results.")
+});
 var searchRecipesOutputShape = {
-  query: z4.string(),
-  results: z4.array(
-    z4.object({
-      id: z4.string().describe("Marmiton recipe id. Pass this to get_recipe."),
-      title: z4.string(),
-      url: z4.string(),
-      image_url: z4.string().nullable()
+  query: z5.string(),
+  results: z5.array(
+    z5.object({
+      id: z5.string().describe("Marmiton recipe id. Pass this to get_recipe."),
+      title: z5.string(),
+      url: z5.string(),
+      image_url: z5.string().nullable()
     })
   ),
-  result_count: z4.number().int(),
-  total_available: z4.number().int().describe("Recipes on this page before applying 'limit'."),
-  source: z4.literal("marmiton.org"),
-  notes: z4.array(z4.string())
+  result_count: z5.number().int(),
+  total_available: z5.number().int().describe("Recipes on this page before applying 'limit'."),
+  source: z5.literal("marmiton.org"),
+  notes: z5.array(z5.string())
 };
 async function runSearchRecipes(client, args) {
   try {
@@ -1691,8 +1846,8 @@ function createServer(options = {}) {
     {
       title: "Search recipes",
       description: searchRecipesDescription,
-      inputSchema: z5.object(searchRecipesInputShape),
-      outputSchema: z5.object(searchRecipesOutputShape),
+      inputSchema: searchRecipesInput,
+      outputSchema: z6.object(searchRecipesOutputShape),
       annotations: READ_ONLY
     },
     async (args) => runSearchRecipes(client, args)
@@ -1702,8 +1857,8 @@ function createServer(options = {}) {
     {
       title: "Get a recipe",
       description: getRecipeDescription,
-      inputSchema: z5.object(getRecipeInputShape),
-      outputSchema: z5.object(getRecipeOutputShape),
+      inputSchema: getRecipeInput,
+      outputSchema: z6.object(getRecipeOutputShape),
       annotations: READ_ONLY
     },
     async (args) => runGetRecipe(client, args)
@@ -1713,8 +1868,8 @@ function createServer(options = {}) {
     {
       title: "Scale an ingredient list",
       description: scaleIngredientsDescription,
-      inputSchema: z5.object(scaleIngredientsInputShape),
-      outputSchema: z5.object(scaleIngredientsOutputShape),
+      inputSchema: scaleIngredientsInput,
+      outputSchema: z6.object(scaleIngredientsOutputShape),
       annotations: OFFLINE
     },
     async (args) => runScaleIngredients(args)