mcp-recipes 1.2.0 → 1.3.0

package/dist/recipe/scale.js

@@ -7,7 +7,10 @@ var ENGLISH_FOODS = /\b(?:eggs?|salt|pepper|sugar|flour|butter|milk|cream|oil|ga
 var STRUCTURAL = 3;
 var VOCABULARY = 2;
 var NAME = 1;
-function readLanguage(line, evidence = { frenchUnit: false, englishUnit: false }) {
+function readLanguage(line, evidence = {
+  frenchUnit: false,
+  englishUnit: false
+}) {
   let french = 0;
   let english = 0;
   if (FRENCH_WORDS.test(line)) french += STRUCTURAL;
@@ -330,8 +333,10 @@ var EMBEDDED = {
 };
 function buildEmbedded(language) {
   const keys = UNIT_KEYS[language].map((key) => key.replace(/ /g, "\\s+"));
-  return new RegExp(`\\d[\\d.,/]*\\s*(?:${keys.join("|")})\\b`, "i");
+  const joiner = "(?:(?:de|du|des|d|of|a|an|the)\\s+)?";
+  return new RegExp(`\\d[\\d.,/]*\\s*${joiner}(?:${keys.join("|")})\\b`, "i");
 }
+var CONTAINER_NOUN = /^(?:cans?|tins?|jars?|packets?|packages?|packs?|box|boxes|bottles?|cartons?|bags?|tubs?|sachets?|blocks?|blocs?|boites?|pots?|briques?|bocaux|bocals?|barquettes?)\b/i;
 function hasEmbeddedMeasure(text, language) {
   return EMBEDDED[language].test(normalizeUnitKey(text));
 }
@@ -476,15 +481,24 @@ function chooseReadableUnit(unit, amount) {
     current = step.unit;
   }
   const up = PROMOTIONS[normalizeUnitKey(current.canonical)];
-  if (up && amount * ratio >= up.per) {
+  if (up && amount * ratio >= up.per && writesExactly(amount * ratio / up.per)) {
     const target = lookupUnit(up.to, up.language);
     if (target) {
       ratio /= up.per;
       current = target;
     }
   }
+  while (!writesExactly(amount * ratio)) {
+    const step = demoteUnit(current);
+    if (!step) break;
+    ratio *= step.per;
+    current = step.unit;
+  }
   return { unit: current, ratio };
 }
+function writesExactly(value) {
+  return Math.abs(value * 100 - Math.round(value * 100)) < 1e-9;
+}
 function formatUnit(unit, amount, language) {
   if (unit.symbol) return unit.canonical;
   const singular = language === "fr" ? amount < 2 : amount <= 1;
@@ -568,6 +582,40 @@ function isStatedSize(text) {
   if (!measure.unit || measure.unit.kind !== "measured") return false;
   return !CONTAINER_CONTENTS.test(measure.rest);
 }
+function takeCompoundMember(text, unit, language) {
+  if (!unit) return null;
+  const step = demoteUnit(unit);
+  if (!step) return null;
+  const joiner = ADDS_UP.exec(text);
+  if (joiner) text = text.slice(joiner[0].length);
+  const second = parseLeadingQuantity(text, language);
+  if (!second || second.amount <= 0 || second.amount >= step.per) return null;
+  const after = text.slice(second.length);
+  const measure = takeUnit(after.trimStart(), language);
+  if (measure.unit) {
+    if (measure.unit.canonical !== step.unit.canonical) return null;
+    return { adds: second.amount / step.per, rest: measure.rest.trimStart() };
+  }
+  if (unit.kind !== "measured") return null;
+  if (!Number.isInteger(second.amount)) return null;
+  const trailing = after.trimStart();
+  if (trailing !== "" && !/^(?:de\s|d'|du\s|des\s|,)/i.test(trailing)) return null;
+  return { adds: second.amount / step.per, rest: trailing };
+}
+var ADDS_UP = /^\s*(?:\+|et|and|plus)\s+/i;
+var LEADING_DECORATION = /^(?:(?!~|≈|\()[^\p{L}\p{N}\s])+(?=\s)/u;
+function takeDecoration(text) {
+  const match = LEADING_DECORATION.exec(text);
+  return match ? match[0] : null;
+}
+function namesContainer(word) {
+  return word !== void 0 && CONTAINER_NOUN.test(normalizeUnitKey(word));
+}
+var TIME_UNIT = {
+  en: /^(?:h|hr|hrs|hours?|mins?|minutes?|secs?|seconds?|days?|nights?|weeks?)\b/i,
+  fr: /^(?:h|mn|heures?|mins?|minutes?|secs?|secondes?|jours?|nuits?|semaines?)\b/i
+};
+var ORDINAL_SUFFIX = /^(?:ers?|[eè]res?|[eè]mes?|es?|st|nd|rd|th)\b/i;
 var PER_PERSON = {
   en: /\bper\s+(?:person|head|serving|guest|diner)\b/i,
   fr: /\bpar\s+(?:personne|convive|part|t\u00eate)\b/i
@@ -690,16 +738,16 @@ function parseLeadingRange(text, language) {
     length: low.length + separator[0].length + high.length
   };
 }
-var FRENCH_ARTICLES = { un: 1, une: 1, quelques: 3 };
+var FRENCH_ARTICLES = { un: 1, une: 1 };
 function takeUnit(text, language) {
   const normalized = normalizeUnitKey(text);
   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 = text.trim().split(/\s+/);
-    return { unit, rest: words.slice(wordCount).join(" ") };
+    const rest = afterKey(text, key);
+    if (rest === null) continue;
+    return { unit, rest };
   }
   if (language === "en") {
     const words = text.trimStart().split(/\s+/);
@@ -708,6 +756,14 @@ function takeUnit(text, language) {
   }
   return { unit: null, rest: text };
 }
+function afterKey(text, key) {
+  const words = text.trim().split(/\s+/);
+  for (let count = 1; count <= words.length; count += 1) {
+    if (normalizeUnitKey(words.slice(0, count).join(" ")) !== key) continue;
+    return words.slice(count).join(" ");
+  }
+  return null;
+}
 function takeUnitEitherLanguage(text, language) {
   const first = takeUnit(text, language);
   if (first.unit) return first;
@@ -723,13 +779,16 @@ function readEvidence(line) {
 }
 function parseIngredient(line, choice = "auto") {
   const original = line;
-  const text = readable(line);
+  const marked = readable(line);
+  const decoration = takeDecoration(marked);
+  const text = decoration ? marked.slice(decoration.length).trimStart() : marked;
   const evidence = readEvidence(text);
   const language = choice === "auto" ? evidence.language : choice;
   const empty = (heldBack) => ({
     original,
     language,
     heldBack,
+    decoration,
     approximation: null,
     measureAdjective: null,
     amount: null,
@@ -738,6 +797,8 @@ function parseIngredient(line, choice = "auto") {
     unit: null,
     alternates: [],
     alternateStyle: null,
+    alternateIntro: null,
+    capacity: null,
     item: text,
     articleWord: null,
     countMultiplier: null
@@ -749,7 +810,10 @@ function parseIngredient(line, choice = "auto") {
   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");
+  const behindFigure = stated.slice(quantity.length);
+  if (new RegExp("^-\\p{L}", "u").test(behindFigure)) return empty("sizeQualifier");
+  if (quantity !== article && ORDINAL_SUFFIX.test(behindFigure)) return empty(null);
+  if (TIME_UNIT[language].test(behindFigure.trimStart())) return empty("duration");
   let rest = stated.slice(quantity.length).trimStart();
   if (language === "en") rest = rest.replace(/^(?:of\s+)?an?\s+/i, "");
   const multiplier = readCountMultiplier(rest);
@@ -761,26 +825,44 @@ function parseIngredient(line, choice = "auto") {
   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;
+  const compound = range ? null : takeCompoundMember(rest, leading.unit, language);
+  if (compound) rest = compound.rest;
+  const whole = quantity.amount + (compound?.adds ?? 0);
+  const introducedBracket = /^(?:de\s+|du\s+|des\s+|d'|of\s+)(?=\()/i.exec(rest);
+  const bracketed = takeAlternates(
+    introducedBracket ? rest.slice(introducedBracket[0].length) : rest,
+    language
+  );
+  rest = bracketed.measures.length > 0 ? bracketed.rest : rest;
   const slashed = bracketed.measures.length > 0 ? null : takeSlashAlternates(rest, language);
   if (slashed) rest = slashed.rest;
-  const item = stripItemLead(rest, language);
+  let item = stripItemLead(rest, language);
+  const trailing = bracketed.measures.length === 0 && !slashed ? takeTrailingAlternates(item, language) : null;
+  if (trailing) item = trailing.item;
+  const group = trailing ?? (bracketed.measures.length > 0 ? bracketed : null);
+  const capacity = group !== null && group.measures.every((measure) => measure.unit?.kind === "measured") && (namesContainer(leading.unit?.canonical) || namesContainer(item)) ? group.published : null;
   if (language === "fr" && !leading.unit && statesItemSize(item)) return empty("itemSize");
   if (language === "fr" && leading.partitive && isStatedSize(item)) return empty("itemSize");
+  if (leading.unit?.kind === "measured" && CONTAINER_NOUN.test(normalizeUnitKey(item))) {
+    return empty("containerSize");
+  }
+  const alternates = capacity !== null ? [] : slashed?.measures ?? group?.measures ?? [];
   return {
     original,
     language,
     heldBack: PER_PERSON[language].test(text) ? "perPerson" : null,
+    decoration,
     approximation: loose ? loose[0] : null,
     measureAdjective: behind?.unit ? described.adjective : null,
-    amount: quantity.amount * times,
+    amount: whole * 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),
+    alternates,
+    alternateStyle: alternates.length === 0 ? null : slashed ? "slash" : trailing ? "trailing" : "bracket",
+    alternateIntro: capacity !== null ? null : group?.intro ?? null,
+    capacity,
+    item,
     articleWord: fromArticle ? article?.word ?? null : null,
     countMultiplier: multiplier?.times ?? null
   };
@@ -796,7 +878,7 @@ function unreadableComma(text, language, evidence) {
 function readArticle(text, 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(text);
+    const match = /^\s*(un|une)\b\s*/i.exec(text);
     if (!match) return null;
     if (!counts(text.slice(match[0].length))) return null;
     const word = match[1];
@@ -836,18 +918,35 @@ function stripItemLead(text, language) {
   return text.replace(/^of\s+/i, "").replace(/^an?\s+/i, "").trim();
 }
 function takeAlternates(text, language) {
-  if (!text.startsWith("(")) return { measures: [], rest: text };
+  const none = { measures: [], intro: null, published: "", rest: text };
+  if (!text.startsWith("(")) return none;
   const close = text.indexOf(")");
-  if (close < 0) return { measures: [], rest: text };
-  const inside = text.slice(1, close);
-  const parts = inside.split("/").map((part) => part.trim());
+  if (close < 0) return none;
+  const read = readBracket(text.slice(0, close + 1), language);
+  if (!read) return none;
+  return { ...read, rest: text.slice(close + 1).trimStart() };
+}
+var EQUIVALENT_INTRODUCER = /^(?:soit|environ|about|approx\.?|approximately|or|ou|=)\s*/i;
+var MEASURE_PARTITIVE = /^(?:de\s+la\s+|de\s+l'|d'|de\s+|du\s+|des\s+|of\s+)/i;
+function takeMeasureAfterQuantity(text, language) {
+  const direct = takeUnitEitherLanguage(text, language);
+  if (direct.unit) return direct;
+  const partitive = MEASURE_PARTITIVE.exec(text);
+  if (!partitive) return direct;
+  return takeUnitEitherLanguage(text.slice(partitive[0].length), language);
+}
+function readBracket(bracket, language) {
+  const inside = bracket.slice(1, -1);
+  const intro = EQUIVALENT_INTRODUCER.exec(inside);
+  const body = intro ? inside.slice(intro[0].length) : inside;
+  const parts = body.split(/(?<!\d)\/|\/(?!\d)/).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: text };
-    const after = takeUnitEitherLanguage(part.slice(quantity.length).trimStart(), language);
-    if (!after.unit || after.rest.trim() !== "") return { measures: [], rest: text };
+    if (!quantity) return null;
+    const after = takeMeasureAfterQuantity(part.slice(quantity.length).trimStart(), language);
+    if (!after.unit || after.rest.trim() !== "") return null;
     measures.push({
       amount: quantity.amount,
       amountMax: range?.max ?? null,
@@ -855,8 +954,17 @@ function takeAlternates(text, language) {
       unit: after.unit
     });
   }
-  if (measures.length === 0) return { measures: [], rest: text };
-  return { measures, rest: text.slice(close + 1).trimStart() };
+  if (measures.length === 0) return null;
+  return { measures, intro: intro ? intro[0].trim() : null, published: bracket };
+}
+function takeTrailingAlternates(item, language) {
+  const closing = /\s*(\([^()]*\))\s*$/.exec(item);
+  if (!closing) return null;
+  const read = readBracket(closing[1], language);
+  if (!read) return null;
+  const head = item.slice(0, closing.index).trim();
+  if (head === "") return null;
+  return { ...read, item: head };
 }
 function takeSlashAlternates(text, language) {
   const measures = [];
@@ -907,6 +1015,7 @@ function roundTo(value, step) {
   return Math.round(Math.round(value / step) * step * 100) / 100;
 }
 function roundMeasured(value) {
+  if (Number.isInteger(value)) return value;
   if (value >= 100) return roundTo(value, 5);
   if (value >= 10) return roundTo(value, 1);
   if (value >= 1) return roundTo(value, 0.1);
@@ -980,6 +1089,10 @@ function landedExactly(exact, amount) {
   if (gap > EXACT_WITHIN) return false;
   return exact === 0 || gap / Math.abs(exact) <= EXACT_SHARE;
 }
+function boundLandedExactly(bound) {
+  const fine = bound.ratio >= 1 ? bound.ratio : 1;
+  return landedExactly(bound.raw * fine, bound.amount * (fine / bound.ratio));
+}
 function scaleMeasure(low, high, unit, factor, divisibility) {
   const raws = high === null ? [low * factor] : [low * factor, high * factor];
   const sources = high === null ? [low] : [low, high];
@@ -995,7 +1108,8 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
         amount: Math.min(usable, ceiling),
         exact,
         clamped: false,
-        raw
+        raw,
+        ratio
       };
     }),
     unit: target
@@ -1010,14 +1124,14 @@ function scaleMeasure(low, high, unit, factor, divisibility) {
     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 { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw, ratio: 1 };
     });
     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 { amount: rounded.value, exact: raw, clamped: rounded.clamped, raw, ratio: 1 };
   });
   return { bounds, unit };
 }
@@ -1146,6 +1260,8 @@ var IRREGULAR_SINGULAR = Object.fromEntries(
   Object.entries(IRREGULAR_PLURAL).map(([one, many]) => [many, one])
 );
 function matchCase(source, replacement) {
+  const hasLetter = new RegExp("\\p{L}", "u").test(source);
+  if (hasLetter && source === source.toUpperCase()) return replacement.toUpperCase();
   if (source[0] === source[0]?.toUpperCase() && source.slice(1) === source.slice(1).toLowerCase()) {
     return replacement[0].toUpperCase() + replacement.slice(1);
   }
@@ -1194,6 +1310,15 @@ function agreeInEnglish(item, amount) {
   else return item;
   return `${words.join(" ")}${tail}`;
 }
+var FRENCH_OU_PLURAL_IN_X = /* @__PURE__ */ new Set([
+  "bijou",
+  "caillou",
+  "chou",
+  "genou",
+  "hibou",
+  "joujou",
+  "pou"
+]);
 var INVARIABLE_FRENCH_NOUN = /* @__PURE__ */ new Set([
   "ananas",
   "anis",
@@ -1271,15 +1396,18 @@ function agreeInFrench(item, amount) {
   const head = words[0] ?? "";
   if (head.length <= 3) return item;
   const wantsPlural = amount >= 2;
-  const isPlural = /s$|eaux$|aux$/i.test(head);
+  const ouPlural = /x$/i.test(head) && FRENCH_OU_PLURAL_IN_X.has(foldWord(head.slice(0, -1)));
+  const isPlural = /s$|eaux$|aux$/i.test(head) || ouPlural;
   if (wantsPlural && !isPlural) {
     if (/[sxz]$/i.test(head)) {
     } else if (/eau$/i.test(head)) words[0] = `${head}x`;
+    else if (FRENCH_OU_PLURAL_IN_X.has(foldWord(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 (ouPlural) words[0] = head.slice(0, -1);
     else if (INVARIABLE_FRENCH_NOUN.has(foldWord(head))) {
     } else words[0] = head.slice(0, -1);
   }
@@ -1303,6 +1431,12 @@ function agreeLeadingAdjective(word, amount, language) {
 function agreeWithAmount(item, amount, language) {
   return language === "fr" ? agreeInFrench(item, amount) : agreeInEnglish(item, amount);
 }
+function agreeCountedContainer(item, amount, language) {
+  if (language === "fr") return agreeInFrench(item, amount);
+  const space = item.indexOf(" ");
+  if (space < 0) return agreeInEnglish(item, amount);
+  return `${agreeInEnglish(item.slice(0, space), amount)}${item.slice(space)}`;
+}
 var MUTE_H_WORDS = /^(?:huile|huiles|huitre|huitres|huître|huîtres|herbe|herbes|hysope)\b/i;
 function joinItem(item, language) {
   if (!item) return "";
@@ -1361,7 +1495,9 @@ function scaleAlternative(tail, options) {
 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.",
   itemSize: "The measure standing behind the item gives the size of one of them rather than how many, so the line is left as published. Serving more people is a matter of taking a bigger one, and serving fewer a smaller one.",
+  containerSize: "The measure here gives what one container holds rather than how many of them the recipe uses, and the line states no count, so it is left as published. Scaling it is a matter of opening that many containers of the size named.",
   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.",
+  duration: "This line states a length of time rather than an amount of an ingredient, so it is left as published. A rest, a proof or a bake takes as long for a large batch as for a small one, and the factor has nothing to say about it.",
   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) {
@@ -1385,10 +1521,12 @@ function scaleSingleLine(line, options) {
   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 movedPrimary = primaryBounds.some((bound) => !boundLandedExactly(bound));
+  const movedAlternate = alternateBounds.some((bound) => !boundLandedExactly(bound));
   const clamped = [...primaryBounds, ...alternateBounds].find((bound) => bound.clamped) ?? null;
   const restated = parsed.alternateStyle === "slash";
+  const carriesMore = hasEmbeddedMeasure(parsed.item, language);
+  const leftover = carriesMore && parsed.unit?.kind === "measured";
   const low = primaryBounds[0];
   const high = primaryBounds[1] ?? null;
   const unit = primary.unit;
@@ -1404,13 +1542,17 @@ function scaleSingleLine(line, options) {
   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 introduced = parsed.alternateIntro ? `${parsed.alternateIntro} ` : "";
+  const bracketed = alternates.length === 0 ? "" : ` (${introduced}${alternateTexts.join(" / ")})`;
+  const altLabel = alternates.length === 0 ? "" : parsed.alternateStyle === "slash" ? ` / ${alternateTexts.join(" / ")}` : parsed.alternateStyle === "trailing" ? "" : bracketed;
+  const trailingLabel = parsed.alternateStyle === "trailing" ? bracketed : "";
+  const capacityLabel = parsed.capacity ? ` ${parsed.capacity}` : "";
+  const counted = parsed.capacity ? agreeCountedContainer(parsed.item, shown, language) : agreeWithAmount(parsed.item, shown, language);
   const itemLabel = named ? joinItem(parsed.item, language) : counted ? ` ${counted}` : "";
   const result = {
-    text: `${parsed.approximation ?? ""}${amountText}${unitLabel}${altLabel}${itemLabel}`.trim(),
+    text: `${parsed.decoration ? `${parsed.decoration} ` : ""}${parsed.approximation ?? ""}${amountText}${unitLabel}${capacityLabel}${altLabel}${itemLabel}${trailingLabel}`.trim(),
     original: parsed.original,
-    scaling: movedPrimary || movedAlternate || restated ? "rounded" : "scaled",
+    scaling: movedPrimary || movedAlternate || restated || leftover ? "rounded" : "scaled",
     amount: low.amount,
     amountMax: collapsed ? null : high?.amount ?? null,
     unit: named?.canonical ?? null,
@@ -1423,7 +1565,7 @@ function scaleSingleLine(line, options) {
       `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));
+    const moved = primaryBounds.filter((bound) => !boundLandedExactly(bound));
     sentences.push(
       moved.map(
         (bound) => `Rounded ${bound.amount > bound.exact ? "up" : "down"} from ${asPublished(bound.raw, parsed.unit)}.`
@@ -1438,11 +1580,16 @@ function scaleSingleLine(line, options) {
       "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)) {
+  if (carriesMore) {
     sentences.push(
       "This line carries a further quantity after the first one, and only the first was scaled. Read the rest as published."
     );
   }
+  if (parsed.capacity) {
+    sentences.push(
+      `${parsed.capacity} is what one container holds, so it stays as published and the count is what the factor moved. Scaling this line is a matter of opening that many containers of the size named.`
+    );
+  }
   if (collapsed) {
     sentences.push("The page gave a range, and at this size both ends come to the same amount.");
   }