mcp-recipes 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -4,10 +4,44 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [1.1.0] - 2026-08-07
 
 ### Changed
 
+- The three readings a comma can take are now told apart. English groups
+  thousands with it and French marks the decimal, so "1,500 g flour" is fifteen
+  hundred grams and "1,500 kg de farine" is a kilo and a half. Where a line
+  gives no sign which language it is in, both readings stand and they differ by
+  a factor of a thousand, so the line comes back as published and says why
+  rather than under a guess.
+
+- A figure that was never a count is no longer multiplied. "4 to 5-pound
+  boneless pork loin roast" describes one roast and was doubled into eight to
+  ten of them, and an amount stated "par personne" or "per person" already
+  carries the change the factor asks for. Both come back as the page published
+  them, with a note saying which of the two it is.
+
+- The quantity behind the word that hid it is read. "~1 cup water", "about 6
+  medium lemons" and "environ 6 citrons" carried an amount that was answered as
+  if the line had none, and "1 grosse pincée de sel" lost the pincée, and with it
+  the fact that a pincée is held to no better than the hand. Both now read
+  through to the figure and the measure, and put the word and the sign back
+  where the page had them.
+
+- HTML entities are decoded, brackets a page left empty are dropped, "recipe"
+  naming another dish takes its plural on the count, and "livre" is read as the
+  pound a French page glosses a weight with.
+
+- An approximate measure lands its count on a whole one. There is no half of a
+  hand: the size of one pincée is the cook's and the count is the whole of what
+  the measure can say, so "1 pincée de sel" halved keeps the pincée and the line
+  reports that it moved, where it answered "1/2 pincée" and called the
+  arithmetic exact.
+
+- A gousse d'ail and a clove of garlic stop at the half rather than the quarter,
+  as the person who cooks these recipes has them, and a baie de genévrier and
+  une étoile de badiane are counted whole.
+
 - How finely a counted thing divides now follows the size of one of them against
   what a recipe puts in, and two families come out of that one comparison. Each
   family is read in both languages, because where a food falls on that
@@ -50,11 +84,9 @@ All notable changes to this project are documented here. The format follows
   Each holds enough that a quarter is still a portion someone serves, so the
   answer is now `1/4 pot de crème fraîche`, exact. The word is read wherever it
   stands, so `1 petit pot de crème` gets the same floor.
-- Une gousse, une tranche and a slice divide as far as the quarter. Each is
-  already cut off something larger, and the board that produced one takes a
-  corner off it in the same gesture, so `1 gousse d'ail` reduced to a quarter
-  comes back as `1/4 gousse d'ail` where it came back as a half, and
-  `4 gousses d'ail` reads `1 gousse d'ail`.
+- Une tranche and a slice divide as far as the quarter. Each is already cut off
+  something larger, and the board that produced one takes a corner off it in the
+  same gesture, so a quarter of a tranche de pain is a crouton.
 - Une pastèque and a watermelon, une pintade and a guinea fowl, un poulet and a
   chicken, un poireau and a leek, une banane and a banana, une mangue and a
   mango, un rôti and a roast, un avocat, un reblochon and une bûche divide as
@@ -68,8 +100,8 @@ All notable changes to this project are documented here. The format follows
   `3 cuisses de poulet` at a half now that the whole poulet goes to the quarter.
 - `clove` is read on the line that writes it, having named two foods with one
   answer between them. Garlic in the line makes it the gousse d'ail, which a
-  knife takes to a quarter, so `4 cloves garlic, minced` reduced to a quarter
-  reads `1 clove garlic, minced`. On its own, or written `whole cloves`, it is
+  knife splits in two, so `4 cloves garlic, minced` reduced to a quarter reads
+  `1 clove garlic, minced`. On its own, or written `whole cloves`, it is
   the clou de girofle dropped into the pot and fished back out: nothing about it
   is measured, so `4 whole cloves` halved reads `2 whole cloves` where it read
   `1 whole clof`. The French words need none of this, each naming one food and
@@ -99,6 +131,21 @@ All notable changes to this project are documented here. The format follows
   unchanged, and the divisibility now comes from the thing counted, so
   `1 ea. onion` goes to a quarter and `12 ea. eggs` lands on a whole number.
 
+### Fixed
+
+- A French produce name opening on an accent is recognised again. A word
+  boundary sits between ASCII letters, so the pattern never matched at the start
+  of "échalote", and a shallot reduced to a quarter was clamped up to a half and
+  told it no longer held its share. The name is now read with its accents folded
+  away, so it comes back as "1/4 échalote", exact.
+
+- A second quantity left at its published size is reported on a French line. The
+  vocabulary is keyed without accents and the line writes "cuillère à soupe" with
+  them, so the sentence was never reached.
+
+- Rounding happens in the smaller of the two units when the answer moves to a
+  bigger one, so a promotion no longer costs precision the page had.
+
 ## [1.0.0] - 2026-02-06
 
 First release.
@@ -144,4 +191,5 @@ First release.
 - A nightly canary against the real sites, which opens an issue when one of them
   changes something this server reads.
 
+[1.1.0]: https://github.com/smeet666/mcp-recipes/releases/tag/v1.1.0
 [1.0.0]: https://github.com/smeet666/mcp-recipes/releases/tag/v1.0.0

package/README.md

@@ -59,9 +59,8 @@ clou de girofle, a zeste and a zest go with it, having no half anyone takes.
 
 A few measures go the other way and divide further. A pot, a bouteille, a
 bottle, a jar and a block hold enough for a quarter to be a portion someone
-serves. Une gousse, une tranche and a slice are already cut off something
-larger, and the board that produced one takes a corner off it in the same
-gesture. And a word can state a number of things rather than a measure of them,
+serves. Une tranche and a slice are already cut off something larger, and the
+board that produced one takes a corner off it in the same gesture. And a word can state a number of things rather than a measure of them,
 so `2 dozen mushrooms` at three quarters comes back as **18 mushrooms**. A blanc
 belongs to whichever food the line named: the white of an egg is counted whole,
 a blanc de poulet is meat and halves.
@@ -82,8 +81,8 @@ taken by squeezing half the fruit, and a quarter of one has to be poured out and
 measured back.
 
 The word `clove` names two foods, and the line says which. Garlic in the line
-makes it the wedge broken off a bulb, the gousse d'ail, which a knife takes to a
-quarter; on its own, or written `whole cloves`, it is the dried flower bud, the
+makes it the wedge broken off a bulb, the gousse d'ail, which a knife splits in
+two; on its own, or written `whole cloves`, it is the dried flower bud, the
 clou de girofle, and a count of those lands on a whole number.
 
 - `3 eggs` taken from six people to twenty-five gives **13 eggs**, and never a

package/dist/index.js

@@ -7,7 +7,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/version.ts
-var PKG_VERSION = "1.0.0";
+var PKG_VERSION = "1.1.0";
 var REPO_URL = "https://github.com/smeet666/mcp-recipes";
 var ISSUES_URL = "https://github.com/smeet666/mcp-recipes/issues";
 
@@ -748,6 +748,12 @@ var FRENCH_UNITS = {
   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 },
+  // A page glossing a metric weight names the pound, which French writes as a
+  // livre: "450 g (1 livre) de spaghetti".
+  livre: { canonical: "livre", kind: "measured", system: "imperial", plural: "livres" },
+  livres: { canonical: "livre", kind: "measured", system: "imperial", plural: "livres" },
+  lb: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
+  lbs: { canonical: "lb", kind: "measured", system: "imperial", symbol: true },
   // Spoons and cups: real measures, but only in sensible fractions.
   "cuillere a soupe": {
     canonical: "cuill\xE8re \xE0 soupe",
@@ -959,6 +965,11 @@ var ENGLISH_UNITS = {
   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 },
+  // A dish of the book standing as an ingredient of another: "1 recipe Flaky
+  // Pie Crust". The count is what the word measures, so the plural mark belongs
+  // on it and not on the name of the dish.
+  recipe: { canonical: "recipe", kind: "portioned", system: "none", plural: "recipes" },
+  recipes: { canonical: "recipe", kind: "portioned", system: "none", plural: "recipes" },
   // 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" },
@@ -1025,7 +1036,7 @@ function buildEmbedded(language) {
   return new RegExp(`\\d[\\d.,/]*\\s*(?:${keys.join("|")})\\b`, "i");
 }
 function hasEmbeddedMeasure(text2, language) {
-  return EMBEDDED[language].test(text2);
+  return EMBEDDED[language].test(normalizeUnitKey(text2));
 }
 var NOT_A_MEASURE = /* @__PURE__ */ new Set([
   "peu",
@@ -1148,9 +1159,10 @@ function isSpoonMeasure(unit) {
   );
 }
 function unitDivisibility(unit) {
+  if (unit.kind === "approximate") return "whole";
   return QUARTERED_MEASURE.test(unit.canonical) ? "quarter" : "half";
 }
-var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|gousses?|tranches?|slices?)\b/i;
+var QUARTERED_MEASURE = /\b(pots?|bouteilles?|bottles?|jars?|blocs?|blocks?|tranches?|slices?)\b/i;
 function countsBarePieces(unit) {
   return unit.canonical === "ea";
 }
@@ -1202,6 +1214,88 @@ var VULGAR_FRACTIONS = {
   "\u215E": 0.875
 };
 var VULGAR_CLASS = Object.keys(VULGAR_FRACTIONS).join("");
+var NAMED_ENTITIES = {
+  frac12: "\xBD",
+  frac13: "\u2153",
+  frac23: "\u2154",
+  frac14: "\xBC",
+  frac34: "\xBE",
+  frac15: "\u2155",
+  frac18: "\u215B",
+  nbsp: " ",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  deg: "\xB0",
+  times: "\xD7",
+  minus: "\u2212",
+  ndash: "\u2013",
+  mdash: "\u2014"
+};
+function decodeEntities(text2) {
+  return text2.replace(/&#x([0-9a-f]+);/gi, (whole, hex) => codePoint(parseInt(hex, 16), whole)).replace(/&#(\d+);/g, (whole, digits) => codePoint(Number(digits), whole)).replace(
+    /&([a-z][a-z0-9]*);/gi,
+    (whole, name) => NAMED_ENTITIES[name.toLowerCase()] ?? whole
+  );
+}
+function codePoint(value, published) {
+  if (!Number.isInteger(value) || value < 32 || value > 1114111) return published;
+  try {
+    return String.fromCodePoint(value);
+  } catch {
+    return published;
+  }
+}
+var EMPTY_BRACKETS = /\(\s*\)/g;
+function readable(text2) {
+  return decodeEntities(text2).replace(EMPTY_BRACKETS, " ").replace(/\s+/g, " ").trim();
+}
+var APPROXIMATION_PREFIX = {
+  en: /^(?:~|\u2248|about|approx\.?|approximately|around|roughly)\s*/i,
+  fr: /^(?:~|\u2248|environ|approximativement|\u00e0 peu pr\u00e8s|a peu pres)\s*/i
+};
+var PER_PERSON = {
+  en: /\bper\s+(?:person|head|serving|guest|diner)\b/i,
+  fr: /\bpar\s+(?:personne|convive|part|t\u00eate)\b/i
+};
+var MEASURE_ADJECTIVES = {
+  en: /* @__PURE__ */ new Set([
+    "big",
+    "generous",
+    "good",
+    "heaped",
+    "heaping",
+    "large",
+    "level",
+    "medium",
+    "scant",
+    "small"
+  ]),
+  fr: /* @__PURE__ */ new Set([
+    "beau",
+    "belle",
+    "bon",
+    "bonne",
+    "grand",
+    "grande",
+    "gros",
+    "grosse",
+    "petit",
+    "petite"
+  ])
+};
+function takeMeasureAdjective(text2, language) {
+  const match = new RegExp("^\\s*(\\p{L}+)\\s+", "u").exec(text2);
+  if (!match) return { adjective: null, rest: text2 };
+  const folded = normalizeUnitKey(match[1]);
+  const listed = MEASURE_ADJECTIVES[language].has(folded) || MEASURE_ADJECTIVES[language].has(folded.replace(/s$/, ""));
+  if (!listed) return { adjective: null, rest: text2 };
+  return { adjective: match[1], rest: text2.slice(match[0].length) };
+}
+var COMMA_GROUPED = /^\s*\d{1,3}(?:,\d{3})+(?!\d)/;
+var COMMA_DECIMAL = /^\s*\d+,\d+/;
 function parseLeadingQuantity(text2, language) {
   const trimmed = text2.trimStart();
   const offset = text2.length - trimmed.length;
@@ -1307,21 +1401,25 @@ function takeUnitEitherLanguage(text2, language) {
   if (first.unit) return first;
   return takeUnit(text2, language === "fr" ? "en" : "fr");
 }
-function detectLanguage(line) {
+function readEvidence(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;
+  return readLanguage(text2, { frenchUnit, englishUnit });
 }
 function parseIngredient(line, choice = "auto") {
   const original = line;
-  const text2 = line.trim();
-  const language = choice === "auto" ? detectLanguage(text2) : choice;
-  const empty = {
+  const text2 = readable(line);
+  const evidence = readEvidence(text2);
+  const language = choice === "auto" ? evidence.language : choice;
+  const empty = (heldBack) => ({
     original,
     language,
+    heldBack,
+    approximation: null,
+    measureAdjective: null,
     amount: null,
     amountMax: null,
     rangeSeparator: null,
@@ -1331,17 +1429,25 @@ function parseIngredient(line, choice = "auto") {
     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 (unreadableComma(text2, language, evidence)) return empty("ambiguousDecimal");
+  const loose = APPROXIMATION_PREFIX[language].exec(text2);
+  const stated = loose ? text2.slice(loose[0].length) : text2;
+  const range = parseLeadingRange(stated, language);
+  const article = range ? null : readArticle(stated, language);
+  const quantity = range ?? parseLeadingQuantity(stated, language) ?? article;
+  if (!quantity) return empty(null);
+  if (new RegExp("^-\\p{L}", "u").test(stated.slice(quantity.length))) return empty("sizeQualifier");
+  let rest = stated.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);
+  const fromArticle = quantity === article;
+  const direct = takeLeadingUnit(rest, language, fromArticle);
+  const described = direct.unit ? { adjective: null, rest } : takeMeasureAdjective(rest, language);
+  const behind = described.adjective ? takeLeadingUnit(described.rest, language, fromArticle) : null;
+  const leading = direct.unit ? direct : behind?.unit ? behind : direct;
   rest = leading.rest;
   const bracketed = takeAlternates(rest, language);
   rest = bracketed.rest;
@@ -1350,6 +1456,9 @@ function parseIngredient(line, choice = "auto") {
   return {
     original,
     language,
+    heldBack: PER_PERSON[language].test(text2) ? "perPerson" : null,
+    approximation: loose ? loose[0] : null,
+    measureAdjective: behind?.unit ? described.adjective : null,
     amount: quantity.amount * times,
     amountMax: range === null ? null : range.max * times,
     rangeSeparator: range?.separator ?? null,
@@ -1357,10 +1466,18 @@ function parseIngredient(line, choice = "auto") {
     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,
+    articleWord: fromArticle ? article?.word ?? null : null,
     countMultiplier: multiplier?.times ?? null
   };
 }
+function unreadableComma(text2, language, evidence) {
+  if (COMMA_GROUPED.test(text2)) {
+    const settled = evidence.french !== evidence.english;
+    return !settled;
+  }
+  if (language === "en") return COMMA_DECIMAL.test(text2);
+  return /^\s*\d+,\d+,\d/.test(text2);
+}
 function readArticle(text2, language) {
   const counts = (rest) => takeLeadingUnit(rest, language, true).unit !== null || readCountMultiplier(rest) !== null;
   if (language === "fr") {
@@ -1556,7 +1673,7 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
   const inUnit = (target, ratio) => ({
     bounds: raws.map((raw, index) => {
       const exact = raw * ratio;
-      const rounded = roundMeasured(exact);
+      const rounded = ratio < 1 ? Number((roundMeasured(raw) * ratio).toPrecision(12)) : roundMeasured(exact);
       const usable = rounded === 0 && exact > 0 ? Number(exact.toPrecision(2)) : rounded;
       const ceiling = factor < 1 ? sources[index] * ratio : Number.POSITIVE_INFINITY;
       return {
@@ -1590,7 +1707,7 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
   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",
+  "\\b(?:shrimps?|prawns?|langoustines?|mussels?|hazelnuts?|peppercorns?|junipers?|grains?|anise|crevettes?|gambas|moules?|noisettes?|genievres?|genevriers?|badianes?|anis)\\b",
   "iu"
 );
 var QUARTERED_ITEM = new RegExp(
@@ -1603,7 +1720,7 @@ var HALVED_CUT = /\b(?:breasts?|thighs?|drumsticks?|wings?|cutlets?|cuisses?|ail
 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";
+  return /\bgarlic\b/i.test(item) ? "half" : "whole";
 }
 var BLANC_OF = /\bblancs?\s+d(?:e\s|['’])/iu;
 var BLANC_OF_EGG = /\bblancs?\s+d(?:e\s|['’])\s*(?:oeufs?|œufs?)\b/iu;
@@ -1611,18 +1728,22 @@ function blancDivisibility(item) {
   if (!BLANC_OF.test(item)) return null;
   return BLANC_OF_EGG.test(item) ? "whole" : "half";
 }
+function foldItem(item) {
+  return item.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\u0153/g, "oe").replace(/\u0152/g, "OE");
+}
 function divisibilityOf(unit, item) {
-  const clove = cloveDivisibility(unit, item);
+  const key = foldItem(item);
+  const clove = cloveDivisibility(unit, key);
   if (clove) return clove;
   if (unit && !countsBarePieces(unit)) return unitDivisibility(unit);
-  const blanc = blancDivisibility(item);
+  const blanc = blancDivisibility(key);
   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";
+  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 INVARIABLE_ITEM = /* @__PURE__ */ new Set([
   "anise",
@@ -1789,6 +1910,8 @@ var AGREEABLE_ADJECTIVES = /* @__PURE__ */ new Set([
   "petite",
   "grand",
   "grande",
+  "gros",
+  "grosse",
   "mur",
   "mure",
   "vert",
@@ -1852,6 +1975,16 @@ function agreeInFrench(item, amount) {
   }
   return words.join(" ");
 }
+function agreeLeadingAdjective(word, amount, language) {
+  if (language === "en") return word;
+  const wantsPlural = amount >= 2;
+  const folded = foldWord(word);
+  const isPlural = folded.endsWith("s") && !AGREEABLE_ADJECTIVES.has(folded);
+  const singular = isPlural ? word.slice(0, -1) : word;
+  if (!AGREEABLE_ADJECTIVES.has(foldWord(singular))) return word;
+  if (wantsPlural === isPlural) return word;
+  return wantsPlural ? `${singular}s` : singular;
+}
 function agreeWithAmount(item, amount, language) {
   return language === "fr" ? agreeInFrench(item, amount) : agreeInEnglish(item, amount);
 }
@@ -1910,11 +2043,16 @@ function scaleAlternative(tail, options) {
   if (largest < 1) return { text: published, rewritten: false };
   return { text: scaleIngredient(tail, options).text, rewritten: true };
 }
+var HELD_BACK_NOTE = {
+  sizeQualifier: "The figures here give the size of one item rather than how many, so the line is left as published.",
+  perPerson: "This line already states an amount for one person, and the factor is what changes how many people the recipe serves, so the line is left as published.",
+  ambiguousDecimal: "The comma in this number marks thousands in one convention and the decimal point in another, and the line gives no sign which was meant, so it is left as published."
+};
 function scaleSingleLine(line, options) {
   const { factor } = options;
   const parsed = parseIngredient(line, options.language ?? "auto");
   const language = parsed.language;
-  if (parsed.amount === null) {
+  if (parsed.amount === null || parsed.heldBack) {
     return {
       text: parsed.original,
       original: parsed.original,
@@ -1923,7 +2061,7 @@ function scaleSingleLine(line, options) {
       amountMax: null,
       unit: null,
       language,
-      note: "No quantity given; adjust to taste."
+      note: parsed.heldBack ? HELD_BACK_NOTE[parsed.heldBack] : "No quantity given; adjust to taste."
     };
   }
   const divisibility = divisibilityOf(parsed.unit, parsed.item);
@@ -1947,13 +2085,14 @@ function scaleSingleLine(line, options) {
     parsed.rangeSeparator
   );
   const named = unit && !countsBarePieces(unit) ? unit : null;
-  const unitLabel = named ? ` ${formatUnit(named, shown, language)}` : "";
+  const adjective = named && parsed.measureAdjective ? ` ${agreeLeadingAdjective(parsed.measureAdjective, shown, language)}` : "";
+  const unitLabel = named ? `${adjective} ${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(),
+    text: `${parsed.approximation ?? ""}${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
     original: parsed.original,
     scaling: movedPrimary || movedAlternate || restated ? "rounded" : "scaled",
     amount: low.amount,
@@ -1996,6 +2135,11 @@ function scaleSingleLine(line, options) {
       "This is smaller than a kitchen scale resolves. Make a larger batch, or measure it by eye."
     );
   }
+  if (parsed.approximation) {
+    sentences.push(
+      "The page gave this amount as an approximation, and the scaled figure is no firmer."
+    );
+  }
   if (sentences.length > 0) result.note = sentences.join(" ");
   if (parsed.unit && parsed.unit.kind === "approximate") {
     result.note = withApproximateNote(parsed.unit, result.note);
@@ -2043,16 +2187,18 @@ function scaleIngredients(lines, options) {
 }
 function passthroughIngredient(line, language = "auto") {
   const parsed = parseIngredient(line, language);
+  const held = parsed.amount === null || parsed.heldBack !== null;
   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,
+    scaling: held ? "unscaled" : "scaled",
+    amount: held ? null : parsed.amount,
+    amountMax: held ? null : parsed.amountMax,
+    unit: held ? null : parsed.unit?.canonical ?? null,
     language: parsed.language
   };
-  if (parsed.amount === null) result.note = "No quantity given; adjust to taste.";
+  if (parsed.heldBack) result.note = HELD_BACK_NOTE[parsed.heldBack];
+  else 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);
   }