mcp-marmiton 1.3.0 → 1.5.0

package/README.md

@@ -4,6 +4,7 @@
 [![CI](https://github.com/smeet666/mcp-marmiton/actions/workflows/ci.yml/badge.svg)](https://github.com/smeet666/mcp-marmiton/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/mcp-marmiton.svg)](./LICENSE)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-6E56CF)](https://registry.modelcontextprotocol.io/v0/servers?search=io.github.smeet666/mcp-marmiton)
+[![Glama](https://glama.ai/mcp/servers/smeet666/mcp-marmiton/badges/score.svg)](https://glama.ai/mcp/servers/smeet666/mcp-marmiton)
 
 An [MCP](https://modelcontextprotocol.io) server for [Marmiton](https://www.marmiton.org),
 the French recipe site. Search recipes, read their ingredients and steps, and
@@ -40,6 +41,14 @@ claude mcp add marmiton -- npx -y mcp-marmiton
 }
 ```
 
+**Bundle, without npm**
+
+Download `mcp-marmiton-<version>.mcpb` from
+[the latest release](https://github.com/smeet666/mcp-marmiton/releases/latest) and open
+it. A client that supports MCP bundles installs it on its own, with no npm and
+no configuration file to edit. The bundle carries its dependencies, so nothing
+is fetched at install time.
+
 ## Tools
 
 | Tool                | What it does                           | Key parameters                                          |
@@ -60,20 +69,44 @@ Asking a language model to divide a recipe by 1.5 tends to produce "2.4 eggs" an
 server does the arithmetic itself and, more importantly, **says what it could not
 compute**. Every ingredient comes back with a `scaling` flag:
 
-| Flag       | Meaning                                          | Example at factor 0.667           |
-| ---------- | ------------------------------------------------ | --------------------------------- |
-| `scaled`   | Multiplied and rounded to a readable value.      | `25 cl de lait` → `17 cl de lait` |
-| `rounded`  | Multiplied, then rounded to something countable. | `3 oeufs` → `2 oeufs`             |
-| `unscaled` | Left exactly as published.                       | `1 pincée de sel`, `coriandre`    |
+| Flag       | Meaning                                            | Example                                  |
+| ---------- | -------------------------------------------------- | ---------------------------------------- |
+| `scaled`   | The value is the product itself.                   | `3 oeufs` ×2 → `6 oeufs`                 |
+| `rounded`  | The value had to be moved to stay usable.          | `25 cl de lait` ×0.667 → `17 cl de lait` |
+| `unscaled` | Carries no quantity, so left exactly as published. | `sel`, `coriandre`                       |
+
+A count reaches an exact product as readily as a mass does: one pinch multiplied
+by six is six pinches, and that line is `scaled`. `rounded` is for a value that
+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.
 
+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
+many are asked for, so the count is multiplied in whole units: `une pincée de
+bicarbonate de soude` from 6 servings to 25 comes back as `4 pincées de
+bicarbonate de soude`, carrying a note. Nothing is ever
+converted into grams or spoons, where published equivalences span a fourfold
+range; an order of magnitude belongs in a note, never in the quantity.
+
 Ranges are read as one quantity: "2 à 3 gousses" doubled reads "4 à 6 gousses",
 and `amount` reports the upper bound, since that is what a cook buys.
 
+A line that writes an article where a digit would go is read as one of the
+measure that follows it: `un bouchon de rhum` scaled sixfold is
+`6 bouchons de rhum`, and the note says which word the figure came from. A noun
+sitting between the amount and the `de` that introduces what is measured names a
+container or a gesture, which is how a measure the vocabulary has never met is
+still read. An article before a bare countable thing, as in `un oignon`, leaves
+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
 baking powder against three pots of flour comes out four times too strong that
@@ -220,6 +253,14 @@ claude mcp add marmiton -- npx -y mcp-marmiton
 }
 ```
 
+**Bundle, sans npm**
+
+Téléchargez `mcp-marmiton-<version>.mcpb` depuis
+[la dernière release](https://github.com/smeet666/mcp-marmiton/releases/latest) et
+ouvrez-le. Un client compatible avec les bundles MCP l'installe seul, sans npm
+ni fichier de configuration à modifier. Le bundle embarque ses dépendances,
+donc rien n'est téléchargé à l'installation.
+
 ## Outils
 
 | Outil               | Rôle                                        | Paramètres principaux                                   |
@@ -240,21 +281,46 @@ et « 0,67 pincée de sel », énoncés avec le même aplomb qu'un chiffre juste
 serveur fait le calcul lui-même et, surtout, **signale ce qu'il n'a pas pu
 calculer**. Chaque ingrédient porte un indicateur `scaling` :
 
-| Indicateur | Sens                                              | Exemple au facteur 0,667          |
-| ---------- | ------------------------------------------------- | --------------------------------- |
-| `scaled`   | Multiplié et arrondi à une valeur lisible.        | `25 cl de lait` → `17 cl de lait` |
-| `rounded`  | Multiplié, puis arrondi à une valeur dénombrable. | `3 oeufs` → `2 oeufs`             |
-| `unscaled` | Laissé exactement tel que publié.                 | `1 pincée de sel`, `coriandre`    |
+| Indicateur | Sens                                                 | Exemple                                  |
+| ---------- | ---------------------------------------------------- | ---------------------------------------- |
+| `scaled`   | La valeur est le produit exact.                      | `3 oeufs` ×2 → `6 oeufs`                 |
+| `rounded`  | La valeur a dû être déplacée pour rester utilisable. | `25 cl de lait` ×0,667 → `17 cl de lait` |
+| `unscaled` | Ne porte aucune quantité, laissé tel que publié.     | `sel`, `coriandre`                       |
+
+Un décompte tombe juste aussi bien qu'une masse : une pincée multipliée par six
+fait six pincées, et cette ligne est `scaled`. `rounded` désigne une valeur posée
+ailleurs que là où le calcul la mettait, un demi-œuf ramené à un œuf entier ou
+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
 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.
 
+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
+multiplié, en unités entières. « une pincée de bicarbonate de soude » de 6 à 25
+parts revient en « 4 pincées de bicarbonate de soude », accompagnée d'une
+note. Aucune conversion en grammes ni en cuillères : les
+équivalences publiées varient du simple au quadruple, et un ordre de grandeur a
+sa place dans une note, jamais dans la quantité.
+
 Les fourchettes sont lues comme une seule quantité : « 2 à 3 gousses » doublé
 donne « 4 à 6 gousses », et `amount` renvoie la borne haute, celle que l'on
 achète.
 
+Une ligne qui écrit un article là où irait un chiffre est lue comme une unité de
+la mesure qui suit : « un bouchon de rhum » multiplié par six donne « 6 bouchons
+de rhum », et la note indique de quel mot vient le chiffre. Un nom placé entre la
+quantité et le « de » qui introduit ce qui est mesuré désigne un contenant ou un
+geste, ce qui permet de lire une mesure absente du vocabulaire. Un article devant
+une chose dénombrable seule, comme « un oignon », laisse la ligne telle que
+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
 de levure face à trois pots de farine ressort ainsi quatre fois trop dosé, donc

package/dist/index.js

@@ -4,7 +4,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/version.ts
-var PKG_VERSION = "1.3.0";
+var PKG_VERSION = "1.5.0";
 var REPO_URL = "https://github.com/smeet666/mcp-marmiton";
 
 // src/config.ts
@@ -752,7 +752,22 @@ var UNITS = {
   feuilles: { canonical: "feuille", kind: "portioned" },
   branche: { canonical: "branche", kind: "portioned" },
   branches: { canonical: "branche", kind: "portioned" },
-  // Deliberately imprecise: the number is a figure of speech.
+  // Approximate by nature: the size of one is the cook's, the count is the
+  // recipe's. See `readPartitiveMeasure` for what puts a word here.
+  bouchon: { canonical: "bouchon", kind: "vague" },
+  bouchons: { canonical: "bouchon", kind: "vague" },
+  larme: { canonical: "larme", kind: "vague" },
+  larmes: { canonical: "larme", kind: "vague" },
+  doigt: { canonical: "doigt", kind: "vague" },
+  doigts: { canonical: "doigt", kind: "vague" },
+  nuage: { canonical: "nuage", kind: "vague" },
+  nuages: { canonical: "nuage", kind: "vague" },
+  louche: { canonical: "louche", kind: "vague" },
+  louches: { canonical: "louche", kind: "vague" },
+  lichette: { canonical: "lichette", kind: "vague" },
+  lichettes: { canonical: "lichette", kind: "vague" },
+  pointe: { canonical: "pointe", kind: "vague" },
+  pointes: { canonical: "pointe", kind: "vague" },
   pincee: { canonical: "pinc\xE9e", kind: "vague", plural: "pinc\xE9es" },
   pincees: { canonical: "pinc\xE9e", kind: "vague", plural: "pinc\xE9es" },
   trait: { canonical: "trait", kind: "vague" },
@@ -762,7 +777,11 @@ var UNITS = {
   goutte: { canonical: "goutte", kind: "vague", plural: "gouttes" },
   gouttes: { canonical: "goutte", kind: "vague", plural: "gouttes" },
   poignee: { canonical: "poign\xE9e", kind: "vague", plural: "poign\xE9es" },
-  poignees: { canonical: "poign\xE9e", kind: "vague", plural: "poign\xE9es" }
+  poignees: { canonical: "poign\xE9e", kind: "vague", plural: "poign\xE9es" },
+  // "noix" carries its own plural mark already.
+  noix: { canonical: "noix", kind: "vague", plural: "noix" },
+  soupcon: { canonical: "soup\xE7on", kind: "vague", plural: "soup\xE7ons" },
+  soupcons: { canonical: "soup\xE7on", kind: "vague", plural: "soup\xE7ons" }
 };
 function normalizeUnitKey(text) {
   return text.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\./g, " ").replace(/\s+/g, " ").trim();
@@ -771,6 +790,48 @@ var UNIT_KEYS = Object.keys(UNITS).sort((a, b) => b.length - a.length);
 function lookupUnit(text) {
   return UNITS[normalizeUnitKey(text)] ?? null;
 }
+var NOT_A_MEASURE = /* @__PURE__ */ new Set([
+  "peu",
+  "beaucoup",
+  "plus",
+  "moins",
+  "assez",
+  "trop",
+  "autant",
+  "tant",
+  "moitie",
+  "quart",
+  "tiers",
+  "reste",
+  "melange",
+  "ensemble"
+]);
+function readPartitiveMeasure(text) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+(?=(?:de|du|des)\\s|d')", "u").exec(text);
+  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)) return null;
+  const canonical = frenchSingular(word);
+  return {
+    unit: { canonical, kind: "vague", plural: frenchPlural(canonical) },
+    rest: text.slice(match[0].length)
+  };
+}
+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 PROMOTIONS = {
   mg: { to: "g", per: 1e3 },
   g: { to: "kg", per: 1e3 },
@@ -791,21 +852,21 @@ function demoteUnit(unit) {
   const target = lookupUnit(step.to);
   return target ? { unit: target, per: step.per } : null;
 }
-function convertToReadableUnit(unit, amount) {
+function readableUnitStep(unit, amount) {
   if (unit.kind !== "measured" || !Number.isFinite(amount) || amount <= 0) {
-    return { amount, unit };
+    return { unit, ratio: 1 };
   }
   const up = PROMOTIONS[unit.canonical];
   if (up && amount >= up.per) {
     const target = lookupUnit(up.to);
-    if (target) return { amount: Math.round(amount / up.per * 100) / 100, unit: target };
+    if (target) return { unit: target, ratio: 1 / up.per };
   }
   const down = DEMOTIONS[unit.canonical];
   if (down && amount < 1) {
     const target = lookupUnit(down.to);
-    if (target) return { amount: Math.round(amount * down.per * 100) / 100, unit: target };
+    if (target) return { unit: target, ratio: down.per };
   }
-  return { amount, unit };
+  return { unit, ratio: 1 };
 }
 function formatUnit(unit, amount) {
   if (unit.symbol) return unit.canonical;
@@ -857,11 +918,53 @@ function parseLeadingQuantity(text) {
   }
   return null;
 }
+var ARTICLE_AMOUNTS = {
+  un: 1,
+  une: 1,
+  quelques: 3
+};
+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;
+  const word = match[1];
+  return {
+    amount: ARTICLE_AMOUNTS[word.toLowerCase()],
+    length: match[0].length,
+    word
+  };
+}
+function matchLeadingUnit(text, partitive = false) {
+  const normalized = normalizeUnitKey(text);
+  for (const key of UNIT_KEYS) {
+    if (normalized !== key && !normalized.startsWith(`${key} `)) continue;
+    const unit = lookupUnit(key);
+    if (!unit) continue;
+    const wordCount = key.split(" ").length;
+    const words = text.trim().split(/\s+/);
+    return {
+      unit,
+      unitText: words.slice(0, wordCount).join(" "),
+      rest: words.slice(wordCount).join(" ")
+    };
+  }
+  const measure = partitive ? readPartitiveMeasure(text) : null;
+  if (measure) {
+    return {
+      unit: measure.unit,
+      unitText: text.trim().split(/\s+/)[0],
+      rest: measure.rest
+    };
+  }
+  return null;
+}
 function parseIngredient(line) {
   const original = line;
   const text = line.trim();
   const range = parseLeadingRange(text);
-  const quantity = range ?? parseLeadingQuantity(text);
+  const article = range ? null : parseLeadingArticle(text);
+  const quantity = range ?? parseLeadingQuantity(text) ?? article;
   if (!quantity) {
     return {
       original,
@@ -870,24 +973,16 @@ function parseIngredient(line) {
       rangeSeparator: null,
       unit: null,
       unitText: null,
-      item: text
+      item: text,
+      articleWord: null
     };
   }
   let rest = text.slice(quantity.length).trimStart();
-  let unit = null;
-  let unitText = null;
-  const normalizedRest = normalizeUnitKey(rest);
-  for (const key of UNIT_KEYS) {
-    if (normalizedRest === key || normalizedRest.startsWith(`${key} `)) {
-      unit = lookupUnit(key);
-      const wordCount = key.split(" ").length;
-      const words = rest.split(/\s+/);
-      unitText = words.slice(0, wordCount).join(" ");
-      rest = words.slice(wordCount).join(" ");
-      break;
-    }
-  }
-  const item = rest.replace(/^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+)/i, "").trim();
+  const matched = matchLeadingUnit(rest, quantity === article);
+  const unit = matched?.unit ?? null;
+  const unitText = matched?.unitText ?? null;
+  if (matched) rest = matched.rest;
+  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,
@@ -895,7 +990,8 @@ function parseIngredient(line) {
     rangeSeparator: range?.separator ?? null,
     unit,
     unitText,
-    item
+    item,
+    articleWord: quantity === article ? article?.word ?? null : null
   };
 }
 function parseLeadingRange(text) {
@@ -948,6 +1044,7 @@ function roundMeasured(value) {
   return Math.round(value * 100) / 100;
 }
 var SMALLEST_USABLE_FRACTION = 0.25;
+var EXACT_WITHIN = 0.01;
 function roundCountable(value, allowHalves, ceiling) {
   if (value <= 0) return { value: 0, clamped: false };
   if (value < 1) {
@@ -965,19 +1062,28 @@ function roundCountable(value, allowHalves, ceiling) {
   }
   return { value: allowHalves ? roundTo(value, 0.5) : Math.round(value), clamped: false };
 }
+function scaleApproximateCount(source, raw, factor) {
+  if (raw <= 0) return 0;
+  const whole = Math.max(1, Math.round(raw));
+  return factor < 1 ? Math.min(whole, source) : Math.max(whole, source);
+}
 function roundMeasuredInUsableUnit(unit, raw) {
   let current = unit;
   let value = raw;
   while (value > 0 && value < 1) {
-    const step = demoteUnit(current);
-    if (!step) break;
-    value *= step.per;
-    current = step.unit;
+    const step2 = demoteUnit(current);
+    if (!step2) break;
+    value *= step2.per;
+    current = step2.unit;
   }
   const rounded = roundMeasured(value);
+  const amount = rounded === 0 && value > 0 ? Number(value.toPrecision(2)) : rounded;
+  const step = readableUnitStep(current, amount);
+  if (step.ratio === 1) return { amount, unit: current, exact: value };
   return {
-    amount: rounded === 0 && value > 0 ? Number(value.toPrecision(2)) : rounded,
-    unit: current
+    amount: Math.round(amount * step.ratio * 100) / 100,
+    unit: step.unit,
+    exact: value * step.ratio
   };
 }
 function agreeWithAmount(item, amount) {
@@ -986,16 +1092,72 @@ function agreeWithAmount(item, amount) {
   const head = words[0] ?? "";
   if (head.length <= 3) return item;
   const wantsPlural = amount >= 2;
-  const isPlural = /s$/i.test(head);
+  const isPlural = /s$|eaux$|aux$/i.test(head);
   if (wantsPlural && !isPlural) {
     if (/[sxz]$/i.test(head)) return item;
-    words[0] = `${head}s`;
+    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 (/[aiou]s$/i.test(head)) return item;
-    words[0] = head.slice(0, -1);
+    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);
+  }
+  const last = words.length - 1;
+  if (last > 0) {
+    const adjective = agreeTrailingAdjective(words[last], wantsPlural);
+    if (adjective) words[last] = adjective;
   }
   return words.join(" ");
 }
+var AGREEABLE_ADJECTIVES = /* @__PURE__ */ new Set([
+  "entier",
+  "entiere",
+  "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;
+}
 var MUTE_H_WORDS = /^(?:huile|huiles|huitre|huitres|huître|huîtres|herbe|herbes|hysope)\b/i;
 function joinItem(item) {
   if (!item) return "";
@@ -1017,34 +1179,42 @@ function scaleIngredient(line, options) {
     };
   }
   const kind = parsed.unit?.kind ?? "countable";
-  if (kind === "vague") {
-    return {
-      original: parsed.original,
-      text: parsed.original,
-      amount: parsed.amount,
-      unit: parsed.unit?.canonical ?? null,
-      scaling: "unscaled",
-      adjusted: false,
-      note: "Measure is approximate by nature; adjust to taste."
-    };
-  }
   const scaleBound = (source) => {
     const raw = source * factor;
+    if (kind === "vague") {
+      return {
+        amount: scaleApproximateCount(source, raw, factor),
+        unit: parsed.unit,
+        exact: raw,
+        raw,
+        clamped: false
+      };
+    }
     if (kind === "measured") {
       const converted = roundMeasuredInUsableUnit(parsed.unit, raw);
-      const readable = convertToReadableUnit(converted.unit, converted.amount);
-      return { amount: readable.amount, unit: readable.unit, raw, clamped: false };
+      return {
+        amount: converted.amount,
+        unit: converted.unit,
+        exact: converted.exact,
+        raw,
+        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);
-    return { amount: rounded.value, unit: parsed.unit, raw, clamped: rounded.clamped };
+    return {
+      amount: rounded.value,
+      unit: parsed.unit,
+      exact: raw,
+      raw,
+      clamped: rounded.clamped
+    };
   };
   const low = scaleBound(parsed.amount);
   const high = parsed.amountMax === null ? null : scaleBound(parsed.amountMax);
   const amount = high?.amount ?? low.amount;
   const unit = high?.unit ?? low.unit;
-  const scaling = kind === "measured" ? "scaled" : "rounded";
   const unitLabel = unit ? ` ${formatUnit(unit, amount)}` : "";
   const itemText = unit ? parsed.item : agreeWithAmount(parsed.item, amount);
   const item = unit ? joinItem(parsed.item) : itemText ? ` ${itemText}` : "";
@@ -1052,7 +1222,9 @@ function scaleIngredient(line, options) {
   const amountText = high === null ? asText(low.amount) : parsed.rangeSeparator === "-" || parsed.rangeSeparator === "\u2013" || parsed.rangeSeparator === "\u2014" ? `${asText(low.amount)}${parsed.rangeSeparator}${asText(high.amount)}` : `${asText(low.amount)} ${parsed.rangeSeparator} ${asText(high.amount)}`;
   const text = `${amountText}${unitLabel}${item}`.trim();
   const bounds = high === null ? [low] : [low, high];
-  const adjusted = bounds.some((bound) => Math.abs(bound.raw - bound.amount) > 0.01);
+  const adjusted = bounds.some((bound) => Math.abs(bound.exact - bound.amount) > EXACT_WITHIN);
+  const clamped = bounds.some((bound) => bound.clamped);
+  const scaling = adjusted || clamped ? "rounded" : "scaled";
   const result = {
     original: parsed.original,
     text,
@@ -1061,13 +1233,33 @@ function scaleIngredient(line, options) {
     scaling,
     adjusted
   };
-  if (bounds.some((bound) => bound.clamped)) {
+  if (kind === "vague") {
+    const one = unit ? formatUnit(unit, 1) : "measure";
+    const many = unit ? formatUnit(unit, 2) : "measures";
+    const sentences = [];
+    if (parsed.articleWord) {
+      sentences.push(`"${parsed.articleWord}" read as ${formatAmount(parsed.amount)}.`);
+    }
+    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 (scaling === "rounded" && adjusted) {
+  } 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)}.`;
+    result.note = result.note ? `${read} ${result.note}` : read;
+  }
   return result;
 }
+var APPROXIMATE_MEASURE_MARKER = "Approximate measure:";
+function isApproximateMeasure(entry) {
+  return entry.note?.includes(APPROXIMATE_MEASURE_MARKER) ?? false;
+}
 function scaleIngredients(lines, options) {
   return lines.map((line) => scaleIngredient(line, options));
 }
@@ -1096,17 +1288,22 @@ var scaledIngredientSchema = z.object({
   ),
   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(
-    "'scaled' was multiplied cleanly. 'rounded' was multiplied then rounded to something countable. 'unscaled' was left alone, either because it carries no quantity or because the measure is approximate by nature."
+    "'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(
-    "True when rounding moved the value away from the exact product. A line can be 'rounded' and still land exactly, as three eggs doubled land on six."
+    "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("Why the line was rounded, clamped or left alone.")
+  note: z.string().optional().describe(
+    "Why the line was rounded, clamped or left alone, including when the measure is approximate and only its count was multiplied."
+  )
 });
+function indentMarkerLines(body) {
+  return body.replace(/^(Note:|Source:)/gm, " $1");
+}
 function ok(structured, text, notes = []) {
   const trailer = notes.map((note) => `Note: ${note}`).join("\n");
   const budget = MAX_TEXT_MIRROR_CHARS - (trailer ? trailer.length + 2 : 0);
-  const body = truncate(text, Math.max(0, budget));
+  const body = truncate(indentMarkerLines(text), Math.max(0, budget));
   return {
     content: [{ type: "text", text: trailer ? `${body}
 
@@ -1129,10 +1326,10 @@ function truncate(text, maxChars) {
 var getRecipeDescription = [
   "Read one Marmiton recipe: ingredients, steps, times, category, rating and nutrition.",
   "Give the id returned by search_recipes, or a marmiton.org recipe URL.",
-  "Set 'servings' to rescale the quantities. Each ingredient reports how it was handled: 'scaled' for grams",
-  "and millilitres, 'rounded' for countable things such as eggs or spoons, and 'unscaled' for lines with no",
-  "quantity or with an approximate one such as a pinch of salt. Trust that flag rather than recomputing:",
-  "the point of scaling here is to avoid answers like '2.4 eggs'.",
+  "Set 'servings' to rescale the quantities. Each ingredient reports how it was handled: 'scaled' when the",
+  "arithmetic came out exact, which a count of eggs, spoons or pinches reaches as readily as a mass in grams,",
+  "'rounded' when the value had to be moved to stay usable, and 'unscaled' for lines carrying no quantity at all.",
+  "Trust that flag rather than recomputing: the point of scaling here is to avoid answers like '2.4 eggs'.",
   "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(" ");
@@ -1218,6 +1415,11 @@ async function runGetRecipe(client, args) {
           `${clampedCount} quantity(ies) fell below the smallest amount worth measuring and were clamped up, so their proportions no longer match the published recipe.`
         );
       }
+      if (ingredients.some(isApproximateMeasure)) {
+        notes.push(
+          "Approximate measures such as a pinch or a handful had their count multiplied; the size of one is yours to judge."
+        );
+      }
       if (ingredients.some((entry) => entry.scaling === "unscaled")) {
         notes.push("Some ingredients carry no usable quantity and were left as published.");
       }
@@ -1295,8 +1497,10 @@ var scaleIngredientsDescription = [
   "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; lines with no quantity, or with an approximate one such",
-  "as a pinch, are returned untouched and flagged. Prefer this over doing the arithmetic yourself."
+  "eggs or spoons are rounded to whole or half units; 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']."),
@@ -1343,7 +1547,8 @@ function runScaleIngredients(args) {
       // the roundable category: at a factor of 100 every egg lands whole.
       rounded: ingredients.filter((entry) => entry.scaling === "rounded" && entry.adjusted).length,
       unscaled: ingredients.filter((entry) => entry.scaling === "unscaled").length,
-      clamped: ingredients.filter((entry) => /clamped up/i.test(entry.note ?? "")).length
+      clamped: ingredients.filter((entry) => /clamped up/i.test(entry.note ?? "")).length,
+      approximate: ingredients.filter(isApproximateMeasure).length
     };
     if (counts.rounded > 0) {
       notes.push(
@@ -1355,6 +1560,11 @@ function runScaleIngredients(args) {
         `${counts.unscaled} line(s) carry no usable quantity and were returned unchanged; adjust to taste.`
       );
     }
+    if (counts.approximate > 0) {
+      notes.push(
+        `${counts.approximate} approximate measure(s) such as a pinch or a handful had their count multiplied; the size of one is yours to judge.`
+      );
+    }
     if (counts.clamped > 0) {
       notes.push(
         `${counts.clamped} quantity(ies) fell below the smallest amount worth measuring and were clamped up, so their proportions no longer match the original recipe.`