soustack 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -1,144 +1,263 @@
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
-import { load } from 'cheerio';
+
+// src/parsers/duration.ts
+var ISO_DURATION_REGEX = /^P(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/i;
+var HUMAN_OVERNIGHT = 8 * 60;
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function parseDuration(iso) {
+  if (typeof iso === "number" && Number.isFinite(iso)) {
+    return iso;
+  }
+  if (!iso || typeof iso !== "string") return null;
+  const trimmed = iso.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(ISO_DURATION_REGEX);
+  if (!match) return null;
+  const [, daysRaw, hoursRaw, minutesRaw, secondsRaw] = match;
+  if (!daysRaw && !hoursRaw && !minutesRaw && !secondsRaw) {
+    return null;
+  }
+  let total = 0;
+  if (daysRaw) total += parseFloat(daysRaw) * 24 * 60;
+  if (hoursRaw) total += parseFloat(hoursRaw) * 60;
+  if (minutesRaw) total += parseFloat(minutesRaw);
+  if (secondsRaw) total += Math.ceil(parseFloat(secondsRaw) / 60);
+  return Math.round(total);
+}
+function formatDuration(minutes) {
+  if (!isFiniteNumber(minutes) || minutes <= 0) {
+    return "PT0M";
+  }
+  const rounded = Math.round(minutes);
+  const days = Math.floor(rounded / (24 * 60));
+  const afterDays = rounded % (24 * 60);
+  const hours = Math.floor(afterDays / 60);
+  const mins = afterDays % 60;
+  let result = "P";
+  if (days > 0) {
+    result += `${days}D`;
+  }
+  if (hours > 0 || mins > 0) {
+    result += "T";
+    if (hours > 0) {
+      result += `${hours}H`;
+    }
+    if (mins > 0) {
+      result += `${mins}M`;
+    }
+  }
+  if (result === "P") {
+    return "PT0M";
+  }
+  return result;
+}
+function parseHumanDuration(text) {
+  if (!text || typeof text !== "string") return null;
+  const normalized = text.toLowerCase().trim();
+  if (!normalized) return null;
+  if (normalized === "overnight") {
+    return HUMAN_OVERNIGHT;
+  }
+  let total = 0;
+  const hourRegex = /(\d+(?:\.\d+)?)\s*(?:hours?|hrs?|hr|h)\b/g;
+  let hourMatch;
+  while ((hourMatch = hourRegex.exec(normalized)) !== null) {
+    total += parseFloat(hourMatch[1]) * 60;
+  }
+  const minuteRegex = /(\d+(?:\.\d+)?)\s*(?:minutes?|mins?|min|m)\b/g;
+  let minuteMatch;
+  while ((minuteMatch = minuteRegex.exec(normalized)) !== null) {
+    total += parseFloat(minuteMatch[1]);
+  }
+  if (total <= 0) {
+    return null;
+  }
+  return Math.round(total);
+}
+function smartParseDuration(input) {
+  const iso = parseDuration(input);
+  if (iso !== null) {
+    return iso;
+  }
+  return parseHumanDuration(input);
+}
 
 // src/parser.ts
-function scaleRecipe(recipe, targetYieldAmount) {
-  const baseYield = recipe.yield?.amount || 1;
-  const multiplier = targetYieldAmount / baseYield;
-  const flatIngredients = flattenIngredients(recipe.ingredients);
-  const scaledIngredientsMap = /* @__PURE__ */ new Map();
-  flatIngredients.forEach((ing) => {
-    if (isIndependent(ing.scaling?.type)) {
-      const computed = calculateIngredient(ing, multiplier);
-      scaledIngredientsMap.set(ing.id || ing.item, computed);
+function scaleRecipe(recipe, options = {}) {
+  const multiplier = resolveMultiplier(recipe, options);
+  const scaled = deepClone(recipe);
+  applyYieldScaling(scaled, options, multiplier);
+  const baseAmounts = collectBaseIngredientAmounts(scaled.ingredients || []);
+  const scaledAmounts = /* @__PURE__ */ new Map();
+  const orderedIngredients = [];
+  collectIngredients(scaled.ingredients || [], orderedIngredients);
+  orderedIngredients.filter((ing) => {
+    var _a2;
+    return (((_a2 = ing.scaling) == null ? void 0 : _a2.type) || "linear") !== "bakers_percentage";
+  }).forEach((ing) => {
+    const key = getIngredientKey(ing);
+    scaledAmounts.set(key, calculateIndependentIngredient(ing, multiplier));
+  });
+  orderedIngredients.filter((ing) => {
+    var _a2;
+    return ((_a2 = ing.scaling) == null ? void 0 : _a2.type) === "bakers_percentage";
+  }).forEach((ing) => {
+    var _a2, _b2;
+    const key = getIngredientKey(ing);
+    const scaling = ing.scaling;
+    if (!(scaling == null ? void 0 : scaling.referenceId)) {
+      throw new Error(`Baker's percentage ingredient "${key}" is missing a referenceId`);
     }
+    const referenceAmount = scaledAmounts.get(scaling.referenceId);
+    if (referenceAmount === void 0) {
+      throw new Error(`Reference ingredient "${scaling.referenceId}" not found for baker's percentage item "${key}"`);
+    }
+    const baseAmount = ((_a2 = ing.quantity) == null ? void 0 : _a2.amount) || 0;
+    const referenceBase = baseAmounts.get(scaling.referenceId);
+    const factor = (_b2 = scaling.factor) != null ? _b2 : referenceBase ? baseAmount / referenceBase : void 0;
+    if (factor === void 0) {
+      throw new Error(`Unable to determine factor for baker's percentage ingredient "${key}"`);
+    }
+    scaledAmounts.set(key, referenceAmount * factor);
   });
-  flatIngredients.forEach((ing) => {
-    if (!isIndependent(ing.scaling?.type)) {
-      if (ing.scaling?.type === "bakers_percentage" && ing.scaling.referenceId) {
-        const refIng = scaledIngredientsMap.get(ing.scaling.referenceId);
-        if (refIng) refIng.amount;
-      }
-      const computed = calculateIngredient(ing, multiplier);
-      scaledIngredientsMap.set(ing.id || ing.item, computed);
+  orderedIngredients.forEach((ing) => {
+    const key = getIngredientKey(ing);
+    const amount = scaledAmounts.get(key);
+    if (amount === void 0) return;
+    if (!ing.quantity) {
+      ing.quantity = { amount, unit: null };
+    } else {
+      ing.quantity.amount = amount;
     }
   });
-  const flatInstructions = flattenInstructions(recipe.instructions);
-  const computedInstructions = flatInstructions.map(
-    (inst) => calculateInstruction(inst, multiplier)
-  );
-  const timing = computedInstructions.reduce(
-    (acc, step) => {
-      if (step.type === "active") acc.active += step.durationMinutes;
-      else acc.passive += step.durationMinutes;
-      acc.total += step.durationMinutes;
-      return acc;
-    },
-    { active: 0, passive: 0, total: 0 }
-  );
-  return {
-    metadata: {
-      targetYield: targetYieldAmount,
-      baseYield,
-      multiplier
-    },
-    ingredients: Array.from(scaledIngredientsMap.values()),
-    instructions: computedInstructions,
-    timing
+  scaleInstructionItems(scaled.instructions || [], multiplier);
+  return scaled;
+}
+function resolveMultiplier(recipe, options) {
+  var _a2, _b2;
+  if (options.multiplier && options.multiplier > 0) {
+    return options.multiplier;
+  }
+  if ((_a2 = options.targetYield) == null ? void 0 : _a2.amount) {
+    const base = ((_b2 = recipe.yield) == null ? void 0 : _b2.amount) || 1;
+    return options.targetYield.amount / base;
+  }
+  return 1;
+}
+function applyYieldScaling(recipe, options, multiplier) {
+  var _a2, _b2, _c, _d, _e, _f, _g;
+  const baseAmount = (_b2 = (_a2 = recipe.yield) == null ? void 0 : _a2.amount) != null ? _b2 : 1;
+  const targetAmount = (_d = (_c = options.targetYield) == null ? void 0 : _c.amount) != null ? _d : baseAmount * multiplier;
+  const unit = (_g = (_e = options.targetYield) == null ? void 0 : _e.unit) != null ? _g : (_f = recipe.yield) == null ? void 0 : _f.unit;
+  if (!recipe.yield && !options.targetYield) return;
+  recipe.yield = {
+    amount: targetAmount,
+    unit: unit != null ? unit : ""
   };
 }
-function isIndependent(type) {
-  return !type || type === "linear" || type === "fixed" || type === "discrete";
+function getIngredientKey(ing) {
+  return ing.id || ing.item;
 }
-function calculateIngredient(ing, multiplier, referenceValue) {
-  const baseAmount = ing.quantity?.amount || 0;
-  const type = ing.scaling?.type || "linear";
-  let newAmount = baseAmount;
+function calculateIndependentIngredient(ing, multiplier) {
+  var _a2, _b2, _c, _d, _e, _f;
+  const baseAmount = ((_a2 = ing.quantity) == null ? void 0 : _a2.amount) || 0;
+  const type = ((_b2 = ing.scaling) == null ? void 0 : _b2.type) || "linear";
   switch (type) {
-    case "linear":
-      newAmount = baseAmount * multiplier;
-      break;
     case "fixed":
-      newAmount = baseAmount;
-      break;
-    case "discrete":
-      const raw = baseAmount * multiplier;
-      const step = ing.scaling.roundTo || 1;
-      newAmount = Math.round(raw / step) * step;
-      break;
-    case "bakers_percentage":
-      newAmount = baseAmount * multiplier;
-      break;
-  }
-  const unit = ing.quantity?.unit || "";
-  const ingredientName = ing.name || extractNameFromItem(ing.item);
-  const text = `${parseFloat(newAmount.toFixed(2))}${unit ? " " + unit : ""} ${ingredientName}`;
-  return {
-    id: ing.id || ing.item,
-    name: ingredientName,
-    amount: newAmount,
-    unit: ing.quantity?.unit || null,
-    text,
-    notes: ing.notes
-  };
-}
-function extractNameFromItem(item) {
-  const match = item.match(/^\s*\d+(?:\.\d+)?\s*\w*\s*(.+)$/);
-  return match ? match[1].trim() : item;
-}
-function calculateInstruction(inst, multiplier) {
-  const baseDuration = inst.timing?.duration || 0;
-  const scalingType = inst.timing?.scaling || "fixed";
-  let newDuration = baseDuration;
-  if (scalingType === "linear") {
-    newDuration = baseDuration * multiplier;
-  } else if (scalingType === "sqrt") {
-    newDuration = baseDuration * Math.sqrt(multiplier);
+      return baseAmount;
+    case "discrete": {
+      const scaled = baseAmount * multiplier;
+      const step = (_d = (_c = ing.scaling) == null ? void 0 : _c.roundTo) != null ? _d : 1;
+      const rounded = Math.round(scaled / step) * step;
+      return Math.round(rounded);
+    }
+    case "proportional": {
+      const factor = (_f = (_e = ing.scaling) == null ? void 0 : _e.factor) != null ? _f : 1;
+      return baseAmount * multiplier * factor;
+    }
+    default:
+      return baseAmount * multiplier;
   }
-  return {
-    id: inst.id || "step",
-    text: inst.text,
-    durationMinutes: Math.ceil(newDuration),
-    type: inst.timing?.type || "active"
-  };
 }
-function flattenIngredients(items) {
-  const result = [];
+function collectIngredients(items, bucket) {
   items.forEach((item) => {
-    if (typeof item === "string") {
-      result.push({ item, quantity: { amount: 0, unit: null }, scaling: { type: "fixed" } });
-    } else if ("subsection" in item) {
-      result.push(...flattenIngredients(item.items));
+    if (typeof item === "string") return;
+    if ("subsection" in item) {
+      collectIngredients(item.items, bucket);
     } else {
-      result.push(item);
+      bucket.push(item);
     }
   });
-  return result;
 }
-function flattenInstructions(items) {
-  const result = [];
+function collectBaseIngredientAmounts(items, map = /* @__PURE__ */ new Map()) {
   items.forEach((item) => {
-    if (typeof item === "string") {
-      result.push({ text: item, timing: { duration: 0, type: "active" } });
-    } else if ("subsection" in item) {
-      result.push(...flattenInstructions(item.items));
+    var _a2, _b2;
+    if (typeof item === "string") return;
+    if ("subsection" in item) {
+      collectBaseIngredientAmounts(item.items, map);
     } else {
-      result.push(item);
+      map.set(getIngredientKey(item), (_b2 = (_a2 = item.quantity) == null ? void 0 : _a2.amount) != null ? _b2 : 0);
     }
   });
-  return result;
+  return map;
+}
+function scaleInstructionItems(items, multiplier) {
+  items.forEach((item) => {
+    if (typeof item === "string") return;
+    if ("subsection" in item) {
+      scaleInstructionItems(item.items, multiplier);
+      return;
+    }
+    const timing = item.timing;
+    if (!timing) return;
+    const baseDuration = toDurationMinutes(timing.duration);
+    const scalingType = timing.scaling || "fixed";
+    let newDuration = baseDuration;
+    if (scalingType === "linear") {
+      newDuration = baseDuration * multiplier;
+    } else if (scalingType === "sqrt") {
+      newDuration = baseDuration * Math.sqrt(multiplier);
+    }
+    timing.duration = Math.ceil(newDuration);
+  });
+}
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function toDurationMinutes(duration) {
+  if (typeof duration === "number" && Number.isFinite(duration)) {
+    return duration;
+  }
+  if (typeof duration === "string" && duration.trim().startsWith("P")) {
+    const parsed = parseDuration(duration.trim());
+    if (parsed !== null) {
+      return parsed;
+    }
+  }
+  return 0;
 }
 
 // src/schema.json
 var schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2",
-  title: "Soustack Recipe Schema v0.2",
+  $id: "http://soustack.org/schema/v0.2.1",
+  title: "Soustack Recipe Schema v0.2.1",
   description: "A portable, scalable, interoperable recipe format.",
   type: "object",
   required: ["name", "ingredients", "instructions"],
+  additionalProperties: false,
+  patternProperties: {
+    "^x-": {}
+  },
   properties: {
+    $schema: {
+      type: "string",
+      format: "uri",
+      description: "Optional schema hint for tooling compatibility"
+    },
     id: {
       type: "string",
       description: "Unique identifier (slug or UUID)"
@@ -147,10 +266,19 @@ var schema_default = {
       type: "string",
       description: "The title of the recipe"
     },
+    title: {
+      type: "string",
+      description: "Optional display title; alias for name"
+    },
     version: {
       type: "string",
       pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "Semantic versioning (e.g., 1.0.0)"
+      description: "DEPRECATED: use recipeVersion for authoring revisions"
+    },
+    recipeVersion: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
     },
     description: {
       type: "string"
@@ -184,6 +312,11 @@ var schema_default = {
       type: "string",
       format: "date-time"
     },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      description: "Free-form vendor metadata"
+    },
     source: {
       type: "object",
       properties: {
@@ -243,24 +376,16 @@ var schema_default = {
       }
     },
     time: {
-      oneOf: [
-        {
-          type: "object",
-          properties: {
-            prep: { type: "number" },
-            active: { type: "number" },
-            passive: { type: "number" },
-            total: { type: "number" }
-          }
-        },
-        {
-          type: "object",
-          properties: {
-            prepTime: { type: "string" },
-            cookTime: { type: "string" }
-          }
-        }
-      ]
+      type: "object",
+      properties: {
+        prep: { type: "number" },
+        active: { type: "number" },
+        passive: { type: "number" },
+        total: { type: "number" },
+        prepTime: { type: "string", format: "duration" },
+        cookTime: { type: "string", format: "duration" }
+      },
+      minProperties: 1
     },
     quantity: {
       type: "object",
@@ -361,7 +486,13 @@ var schema_default = {
           type: "object",
           required: ["duration", "type"],
           properties: {
-            duration: { type: "number" },
+            duration: {
+              anyOf: [
+                { type: "number" },
+                { type: "string", pattern: "^P" }
+              ],
+              description: "Minutes as a number or ISO8601 duration string"
+            },
             type: { type: "string", enum: ["active", "passive"] },
             scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
           }
@@ -455,665 +586,756 @@ var schema_default = {
   }
 };
 
-// src/validator.ts
-var ajv = new Ajv();
-addFormats(ajv);
-var validate = ajv.compile(schema_default);
-function validateRecipe(data) {
-  const isValid = validate(data);
-  if (!isValid) {
-    throw new Error(JSON.stringify(validate.errors, null, 2));
-  }
-  return true;
-}
-
-// src/parsers/ingredient.ts
-var FRACTION_DECIMALS = {
-  "\xBD": 0.5,
-  "\u2153": 1 / 3,
-  "\u2154": 2 / 3,
-  "\xBC": 0.25,
-  "\xBE": 0.75,
-  "\u2155": 0.2,
-  "\u2156": 0.4,
-  "\u2157": 0.6,
-  "\u2158": 0.8,
-  "\u2159": 1 / 6,
-  "\u215A": 5 / 6,
-  "\u215B": 0.125,
-  "\u215C": 0.375,
-  "\u215D": 0.625,
-  "\u215E": 0.875
-};
-var NUMBER_WORDS = {
-  zero: 0,
-  one: 1,
-  two: 2,
-  three: 3,
-  four: 4,
-  five: 5,
-  six: 6,
-  seven: 7,
-  eight: 8,
-  nine: 9,
-  ten: 10,
-  eleven: 11,
-  twelve: 12,
-  thirteen: 13,
-  fourteen: 14,
-  fifteen: 15,
-  sixteen: 16,
-  seventeen: 17,
-  eighteen: 18,
-  nineteen: 19,
-  twenty: 20,
-  thirty: 30,
-  forty: 40,
-  fifty: 50,
-  sixty: 60,
-  seventy: 70,
-  eighty: 80,
-  ninety: 90,
-  hundred: 100,
-  half: 0.5,
-  quarter: 0.25
-};
-var UNIT_SYNONYMS = {
-  cup: "cup",
-  cups: "cup",
-  c: "cup",
-  tbsp: "tbsp",
-  tablespoon: "tbsp",
-  tablespoons: "tbsp",
-  tbs: "tbsp",
-  tsp: "tsp",
-  teaspoon: "tsp",
-  teaspoons: "tsp",
-  t: "tsp",
-  gram: "g",
-  grams: "g",
-  g: "g",
-  kilogram: "kg",
-  kilograms: "kg",
-  kg: "kg",
-  milliliter: "ml",
-  milliliters: "ml",
-  ml: "ml",
-  liter: "l",
-  liters: "l",
-  l: "l",
-  ounce: "oz",
-  ounces: "oz",
-  oz: "oz",
-  pound: "lb",
-  pounds: "lb",
-  lb: "lb",
-  lbs: "lb",
-  pint: "pint",
-  pints: "pint",
-  quart: "quart",
-  quarts: "quart",
-  stick: "stick",
-  sticks: "stick",
-  dash: "dash",
-  pinches: "pinch",
-  pinch: "pinch"
-};
-var PREP_PHRASES = [
-  "diced",
-  "finely diced",
-  "roughly diced",
-  "minced",
-  "finely minced",
-  "chopped",
-  "finely chopped",
-  "roughly chopped",
-  "sliced",
-  "thinly sliced",
-  "thickly sliced",
-  "grated",
-  "finely grated",
-  "zested",
-  "sifted",
-  "softened",
-  "at room temperature",
-  "room temperature",
-  "room temp",
-  "melted",
-  "toasted",
-  "drained",
-  "drained and rinsed",
-  "beaten",
-  "divided",
-  "cut into cubes",
-  "cut into pieces",
-  "cut into strips",
-  "cut into chunks",
-  "cut into bite-size pieces"
-].map((value) => value.toLowerCase());
-var COUNT_DESCRIPTORS = /* @__PURE__ */ new Set([
-  "clove",
-  "cloves",
-  "can",
-  "cans",
-  "stick",
-  "sticks",
-  "sprig",
-  "sprigs",
-  "bunch",
-  "bunches",
-  "slice",
-  "slices",
-  "package",
-  "packages"
-]);
-var DESCRIPTOR_NOTE_SET = /* @__PURE__ */ new Set(["can", "cans", "jar", "jars", "package", "packages", "bottle", "bottles"]);
-var WEIGHT_PRIORITY_UNITS = /* @__PURE__ */ new Set(["g", "kg", "oz", "lb", "ml", "l"]);
-var SPICE_KEYWORDS = [
-  "salt",
-  "pepper",
-  "paprika",
-  "cumin",
-  "coriander",
-  "turmeric",
-  "chili powder",
-  "garlic powder",
-  "onion powder",
-  "cayenne",
-  "cinnamon",
-  "nutmeg",
-  "allspice",
-  "ginger",
-  "oregano",
-  "thyme",
-  "rosemary",
-  "basil",
-  "sage",
-  "clove",
-  "spice",
-  "seasoning"
-];
-var PURPOSE_KEYWORDS = ["frying", "greasing", "drizzling", "garnish", "serving", "brushing"];
-var RANGE_REGEX = /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)(?:\s*(?:-|to)\s*((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?))/i;
-var NUMBER_REGEX = /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)/i;
-var QUALIFIER_REGEX = /^(about|around|approximately|approx\.?|roughly)\s+/i;
-var FLAVOR_NOTE_REGEX = /\b(to taste|as needed|as necessary)\b/gi;
-var VAGUE_QUANTITY_PATTERNS = [
-  { regex: /^(a\s+pinch|pinch)\b/i, note: "a pinch" },
-  { regex: /^(a\s+handful|handful)\b/i, note: "a handful" },
-  { regex: /^(a\s+dash|dash)\b/i, note: "a dash" },
-  { regex: /^(a\s+sprinkle|sprinkle)\b/i, note: "a sprinkle" },
-  { regex: /^(some)\b/i, note: "some" },
-  { regex: /^(few\s+sprigs)/i, note: "few sprigs" },
-  { regex: /^(a\s+few|few)\b/i, note: "a few" },
-  { regex: /^(several)\b/i, note: "several" }
-];
-var JUICE_PREFIXES = ["juice of", "zest of"];
-function normalizeIngredientInput(input) {
-  if (!input) return "";
-  let result = input.replace(/\u00A0/g, " ").trim();
-  result = replaceDashes(result);
-  result = replaceUnicodeFractions(result);
-  result = replaceNumberWords(result);
-  result = result.replace(/\s+/g, " ").trim();
-  return result;
-}
-function parseIngredient(text) {
-  const original = text ?? "";
-  const normalized = normalizeIngredientInput(original);
-  if (!normalized) {
-    return {
-      item: original,
-      scaling: { type: "linear" }
-    };
-  }
-  let working = normalized;
-  const notes = [];
-  let optional = false;
-  if (/\boptional\b/i.test(working)) {
-    optional = true;
-    working = working.replace(/\(?\s*optional\s*\)?/gi, "").trim();
-    working = working.replace(/\(\s*\)/g, " ").trim();
-  }
-  const flavorExtraction = extractFlavorNotes(working);
-  working = flavorExtraction.cleaned;
-  notes.push(...flavorExtraction.notes);
-  const parenthetical = extractParentheticals(working);
-  working = parenthetical.cleaned;
-  notes.push(...parenthetical.notes);
-  optional = optional || parenthetical.optional;
-  const purposeExtraction = extractPurposeNotes(working);
-  working = purposeExtraction.cleaned;
-  notes.push(...purposeExtraction.notes);
-  const juiceExtraction = extractJuicePhrase(working);
-  if (juiceExtraction) {
-    working = juiceExtraction.cleaned;
-    notes.push(juiceExtraction.note);
-  }
-  const vagueQuantity = extractVagueQuantity(working);
-  let quantityResult;
-  if (vagueQuantity) {
-    notes.push(vagueQuantity.note);
-    quantityResult = {
-      amount: null,
-      unit: null,
-      descriptor: void 0,
-      remainder: vagueQuantity.remainder,
-      notes: [],
-      originalAmount: null
-    };
-  } else {
-    quantityResult = extractQuantity(working);
-  }
-  working = quantityResult.remainder;
-  const { quantity, usedParenthetical } = mergeQuantities(quantityResult, parenthetical.measurement);
-  if (usedParenthetical && quantityResult.originalAmount !== null && quantityResult.originalAmount > 1 && quantityResult.descriptor && DESCRIPTOR_NOTE_SET.has(quantityResult.descriptor.toLowerCase())) {
-    notes.push(formatCountNote(quantityResult.originalAmount, quantityResult.descriptor));
-  }
-  notes.push(...quantityResult.notes);
-  working = working.replace(/^[,.\s-]+/, "").trim();
-  working = working.replace(/^of\s+/i, "").trim();
-  if (quantityResult.descriptor && /^cans?$/i.test(quantityResult.descriptor) && working && !/^canned\b/i.test(working)) {
-    working = `canned ${working}`.trim();
-  }
-  const nameExtraction = extractNameAndPrep(working);
-  notes.push(...nameExtraction.notes);
-  const name = nameExtraction.name || void 0;
-  const scaling = inferScaling(
-    name,
-    quantity.unit,
-    quantity.amount,
-    notes,
-    quantityResult.descriptor
-  );
-  const mergedNotes = formatNotes(notes);
-  const parsed = {
-    item: original,
-    quantity,
-    ...name ? { name } : {},
-    ...nameExtraction.prep ? { prep: nameExtraction.prep } : {},
-    ...optional ? { optional: true } : {},
-    scaling
-  };
-  if (mergedNotes) {
-    parsed.notes = mergedNotes;
-  }
-  return parsed;
-}
-function parseIngredientLine(text) {
-  return parseIngredient(text);
-}
-function parseIngredients(texts) {
-  if (!Array.isArray(texts)) return [];
-  return texts.map((item) => typeof item === "string" ? item : String(item ?? "")).map((entry) => parseIngredient(entry));
-}
-function replaceDashes(value) {
-  return value.replace(/[\u2012\u2013\u2014\u2212]/g, "-");
-}
-function replaceUnicodeFractions(value) {
-  return value.replace(/(\d+)?(?:\s+)?([½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞])/g, (_match, whole, fraction) => {
-    const fractionValue = FRACTION_DECIMALS[fraction];
-    if (fractionValue === void 0) return _match;
-    const base = whole ? parseInt(whole, 10) : 0;
-    const combined = base + fractionValue;
-    return formatDecimal(combined);
-  });
-}
-function replaceNumberWords(value) {
-  return value.replace(
-    /\b(zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|half|quarter)(?:-(one|two|three|four|five|six|seven|eight|nine))?\b/gi,
-    (match, word, hyphenPart) => {
-      const lower = word.toLowerCase();
-      const baseValue = NUMBER_WORDS[lower];
-      if (baseValue === void 0) return match;
-      if (!hyphenPart) {
-        return formatDecimal(baseValue);
+// src/soustack.schema.json
+var soustack_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1",
+  title: "Soustack Recipe Schema v0.2.1",
+  description: "A portable, scalable, interoperable recipe format.",
+  type: "object",
+  required: ["name", "ingredients", "instructions"],
+  additionalProperties: false,
+  patternProperties: {
+    "^x-": {}
+  },
+  properties: {
+    $schema: {
+      type: "string",
+      format: "uri",
+      description: "Optional schema hint for tooling compatibility"
+    },
+    id: {
+      type: "string",
+      description: "Unique identifier (slug or UUID)"
+    },
+    name: {
+      type: "string",
+      description: "The title of the recipe"
+    },
+    title: {
+      type: "string",
+      description: "Optional display title; alias for name"
+    },
+    version: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "DEPRECATED: use recipeVersion for authoring revisions"
+    },
+    recipeVersion: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
+    },
+    description: {
+      type: "string"
+    },
+    category: {
+      type: "string",
+      examples: ["Main Course", "Dessert"]
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" }
+    },
+    image: {
+      description: "Recipe-level hero image(s)",
+      anyOf: [
+        {
+          type: "string",
+          format: "uri"
+        },
+        {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            format: "uri"
+          }
+        }
+      ]
+    },
+    dateAdded: {
+      type: "string",
+      format: "date-time"
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      description: "Free-form vendor metadata"
+    },
+    source: {
+      type: "object",
+      properties: {
+        author: { type: "string" },
+        url: { type: "string", format: "uri" },
+        name: { type: "string" },
+        adapted: { type: "boolean" }
       }
-      const hyphenValue = NUMBER_WORDS[hyphenPart.toLowerCase()];
-      if (hyphenValue === void 0) {
-        return formatDecimal(baseValue);
+    },
+    yield: {
+      $ref: "#/definitions/yield"
+    },
+    time: {
+      $ref: "#/definitions/time"
+    },
+    equipment: {
+      type: "array",
+      items: { $ref: "#/definitions/equipment" }
+    },
+    ingredients: {
+      type: "array",
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/ingredient" },
+          { $ref: "#/definitions/ingredientSubsection" }
+        ]
       }
-      return formatDecimal(baseValue + hyphenValue);
-    }
-  );
-}
-function formatDecimal(value) {
-  if (Number.isInteger(value)) {
-    return value.toString();
-  }
-  return parseFloat(value.toFixed(3)).toString().replace(/\.0+$/, "");
-}
-function extractFlavorNotes(value) {
-  const notes = [];
-  const cleaned = value.replace(FLAVOR_NOTE_REGEX, (_, phrase) => {
-    notes.push(phrase.toLowerCase());
-    return "";
-  });
-  return {
-    cleaned: cleaned.replace(/\s+/g, " ").trim(),
-    notes
-  };
-}
-function extractPurposeNotes(value) {
-  const notes = [];
-  let working = value.trim();
-  let match = working.match(/\bfor\s+(frying|greasing|drizzling|garnish|serving|brushing)\b\.?$/i);
-  if (match) {
-    notes.push(`for ${match[1].toLowerCase()}`);
-    working = working.slice(0, match.index).trim();
-  }
-  return { cleaned: working, notes };
-}
-function extractJuicePhrase(value) {
-  const lower = value.toLowerCase();
-  for (const prefix of JUICE_PREFIXES) {
-    if (lower.startsWith(prefix)) {
-      const remainder = value.slice(prefix.length).trim();
-      if (!remainder) break;
-      const cleanedSource = remainder.replace(/^of\s+/i, "").trim();
-      if (!cleanedSource) break;
-      const sourceForName = cleanedSource.replace(
-        /^(?:\d+(?:\.\d+)?|\d+\s+\d+\/\d+|\d+\/\d+|one|two|three|four|five|six|seven|eight|nine|ten|a|an)\s+/i,
-        ""
-      ).replace(/^(?:large|small|medium)\s+/i, "").trim();
-      const baseName = sourceForName || cleanedSource;
-      const singular = singularize(baseName);
-      const suffix = prefix.startsWith("zest") ? "zest" : "juice";
-      return {
-        cleaned: `${singular} ${suffix}`.trim(),
-        note: `from ${cleanedSource}`
-      };
+    },
+    instructions: {
+      type: "array",
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/instruction" },
+          { $ref: "#/definitions/instructionSubsection" }
+        ]
+      }
+    },
+    storage: {
+      $ref: "#/definitions/storage"
+    },
+    substitutions: {
+      type: "array",
+      items: { $ref: "#/definitions/substitution" }
     }
-  }
-  return void 0;
-}
-function extractVagueQuantity(value) {
-  for (const pattern of VAGUE_QUANTITY_PATTERNS) {
-    const match = value.match(pattern.regex);
-    if (match) {
-      let remainder = value.slice(match[0].length).trim();
-      remainder = remainder.replace(/^of\s+/i, "").trim();
-      return {
-        remainder,
-        note: pattern.note
-      };
+  },
+  definitions: {
+    yield: {
+      type: "object",
+      required: ["amount", "unit"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: "string" },
+        servings: { type: "number" },
+        description: { type: "string" }
+      }
+    },
+    time: {
+      type: "object",
+      properties: {
+        prep: { type: "number" },
+        active: { type: "number" },
+        passive: { type: "number" },
+        total: { type: "number" },
+        prepTime: { type: "string", format: "duration" },
+        cookTime: { type: "string", format: "duration" }
+      },
+      minProperties: 1
+    },
+    quantity: {
+      type: "object",
+      required: ["amount"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: ["string", "null"] }
+      }
+    },
+    scaling: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
+        },
+        factor: { type: "number" },
+        referenceId: { type: "string" },
+        roundTo: { type: "number" },
+        min: { type: "number" },
+        max: { type: "number" }
+      },
+      if: {
+        properties: { type: { const: "bakers_percentage" } }
+      },
+      then: {
+        required: ["referenceId"]
+      }
+    },
+    ingredient: {
+      type: "object",
+      required: ["item"],
+      properties: {
+        id: { type: "string" },
+        item: { type: "string" },
+        quantity: { $ref: "#/definitions/quantity" },
+        name: { type: "string" },
+        aisle: { type: "string" },
+        prep: { type: "string" },
+        prepAction: { type: "string" },
+        prepTime: { type: "number" },
+        destination: { type: "string" },
+        scaling: { $ref: "#/definitions/scaling" },
+        critical: { type: "boolean" },
+        optional: { type: "boolean" },
+        notes: { type: "string" }
+      }
+    },
+    ingredientSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: { $ref: "#/definitions/ingredient" }
+        }
+      }
+    },
+    equipment: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        required: { type: "boolean" },
+        label: { type: "string" },
+        capacity: { $ref: "#/definitions/quantity" },
+        scalingLimit: { type: "number" },
+        alternatives: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    },
+    instruction: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        id: { type: "string" },
+        text: { type: "string" },
+        image: {
+          type: "string",
+          format: "uri",
+          description: "Optional image that illustrates this instruction"
+        },
+        destination: { type: "string" },
+        dependsOn: {
+          type: "array",
+          items: { type: "string" }
+        },
+        inputs: {
+          type: "array",
+          items: { type: "string" }
+        },
+        timing: {
+          type: "object",
+          required: ["duration", "type"],
+          properties: {
+            duration: {
+              anyOf: [
+                { type: "number" },
+                { type: "string", pattern: "^P" }
+              ],
+              description: "Minutes as a number or ISO8601 duration string"
+            },
+            type: { type: "string", enum: ["active", "passive"] },
+            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+          }
+        }
+      }
+    },
+    instructionSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: {
+            anyOf: [
+              { type: "string" },
+              { $ref: "#/definitions/instruction" }
+            ]
+          }
+        }
+      }
+    },
+    storage: {
+      type: "object",
+      properties: {
+        roomTemp: { $ref: "#/definitions/storageMethod" },
+        refrigerated: { $ref: "#/definitions/storageMethod" },
+        frozen: {
+          allOf: [
+            { $ref: "#/definitions/storageMethod" },
+            {
+              type: "object",
+              properties: { thawing: { type: "string" } }
+            }
+          ]
+        },
+        reheating: { type: "string" },
+        makeAhead: {
+          type: "array",
+          items: {
+            allOf: [
+              { $ref: "#/definitions/storageMethod" },
+              {
+                type: "object",
+                required: ["component", "storage"],
+                properties: {
+                  component: { type: "string" },
+                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    storageMethod: {
+      type: "object",
+      required: ["duration"],
+      properties: {
+        duration: { type: "string", pattern: "^P" },
+        method: { type: "string" },
+        notes: { type: "string" }
+      }
+    },
+    substitution: {
+      type: "object",
+      required: ["ingredient"],
+      properties: {
+        ingredient: { type: "string" },
+        critical: { type: "boolean" },
+        notes: { type: "string" },
+        alternatives: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "ratio"],
+            properties: {
+              name: { type: "string" },
+              ratio: { type: "string" },
+              notes: { type: "string" },
+              impact: { type: "string" },
+              dietary: {
+                type: "array",
+                items: { type: "string" }
+              }
+            }
+          }
+        }
+      }
     }
   }
-  return void 0;
-}
-function extractParentheticals(value) {
-  let optional = false;
-  let measurement;
-  const notes = [];
-  const cleaned = value.replace(/\(([^)]+)\)/g, (_match, group) => {
-    const trimmed = String(group).trim();
-    if (!trimmed) return "";
-    if (/optional/i.test(trimmed)) {
-      optional = true;
-      return "";
+};
+
+// src/profiles/base.schema.json
+var base_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/base",
+  title: "Soustack Base Profile Schema",
+  description: "Wrapper schema that exposes the unmodified Soustack base schema.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" }
+  ]
+};
+
+// src/profiles/cookable.schema.json
+var cookable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/cookable",
+  title: "Soustack Cookable Profile Schema",
+  description: "Extends the base schema to require structured yield + time metadata and non-empty ingredient/instruction lists.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      required: ["yield", "time", "ingredients", "instructions"],
+      properties: {
+        yield: { $ref: "http://soustack.org/schema/v0.2.1#/definitions/yield" },
+        time: { $ref: "http://soustack.org/schema/v0.2.1#/definitions/time" },
+        ingredients: { type: "array", minItems: 1 },
+        instructions: { type: "array", minItems: 1 }
+      }
     }
-    const maybeMeasurement = parseMeasurement(trimmed);
-    if (maybeMeasurement && !measurement) {
-      measurement = maybeMeasurement;
-      return "";
+  ]
+};
+
+// src/profiles/quantified.schema.json
+var quantified_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/quantified",
+  title: "Soustack Quantified Profile Schema",
+  description: "Extends the base schema to require quantified ingredient entries.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      properties: {
+        ingredients: {
+          type: "array",
+          items: {
+            anyOf: [
+              { $ref: "#/definitions/quantifiedIngredient" },
+              { $ref: "#/definitions/quantifiedIngredientSubsection" }
+            ]
+          }
+        }
+      }
     }
-    notes.push(trimmed);
-    return "";
-  });
-  return {
-    cleaned: cleaned.replace(/\s+/g, " ").trim(),
-    measurement,
-    notes,
-    optional
-  };
-}
-function parseMeasurement(value) {
-  const stripped = value.replace(/^(about|around|approximately|approx\.?|roughly)\s+/i, "").trim();
-  const match = stripped.match(
-    /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)(?:\s*)([a-zA-Z]+)?$/
-  );
-  if (!match) return void 0;
-  const amount = parseNumber(match[1]);
-  if (amount === null) return void 0;
-  const unit = match[2] ? normalizeUnit(match[2]) ?? match[2].toLowerCase() : null;
-  return { amount, unit };
-}
-function extractQuantity(value) {
-  let working = value.trim();
-  const notes = [];
-  let amount = null;
-  let originalAmount = null;
-  let unit = null;
-  let descriptor;
-  while (QUALIFIER_REGEX.test(working)) {
-    working = working.replace(QUALIFIER_REGEX, "").trim();
-  }
-  const rangeMatch = working.match(RANGE_REGEX);
-  if (rangeMatch) {
-    amount = parseNumber(rangeMatch[1]);
-    originalAmount = amount;
-    const rangeText = rangeMatch[0].trim();
-    const afterRange = working.slice(rangeMatch[0].length).trim();
-    const descriptorMatch = afterRange.match(/^([a-zA-Z]+)/);
-    if (descriptorMatch && COUNT_DESCRIPTORS.has(descriptorMatch[1].toLowerCase())) {
-      notes.push(`${rangeText} ${descriptorMatch[1]}`);
-    } else {
-      notes.push(rangeText);
+  ],
+  definitions: {
+    quantifiedIngredient: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/ingredient" },
+        { required: ["item", "quantity"] }
+      ]
+    },
+    quantifiedIngredientSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/ingredientSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              items: { $ref: "#/definitions/quantifiedIngredient" }
+            }
+          }
+        }
+      ]
     }
-    working = afterRange;
-  } else {
-    const numberMatch = working.match(NUMBER_REGEX);
-    if (numberMatch) {
-      amount = parseNumber(numberMatch[1]);
-      originalAmount = amount;
-      working = working.slice(numberMatch[0].length).trim();
+  }
+};
+
+// src/profiles/illustrated.schema.json
+var illustrated_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/illustrated",
+  title: "Soustack Illustrated Profile Schema",
+  description: "Extends the base schema to guarantee at least one illustrative image.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      anyOf: [
+        { required: ["image"] },
+        {
+          properties: {
+            instructions: {
+              type: "array",
+              contains: {
+                anyOf: [
+                  { $ref: "#/definitions/imageInstruction" },
+                  { $ref: "#/definitions/instructionSubsectionWithImage" }
+                ]
+              }
+            }
+          }
+        }
+      ]
+    }
+  ],
+  definitions: {
+    imageInstruction: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instruction" },
+        { required: ["image"] }
+      ]
+    },
+    instructionSubsectionWithImage: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instructionSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              contains: { $ref: "#/definitions/imageInstruction" }
+            }
+          }
+        }
+      ]
     }
   }
-  if (working) {
-    const unitMatch = working.match(/^([a-zA-Z]+)\b/);
-    if (unitMatch) {
-      const normalized = normalizeUnit(unitMatch[1]);
-      if (normalized) {
-        unit = normalized;
-        working = working.slice(unitMatch[0].length).trim();
-      } else if (COUNT_DESCRIPTORS.has(unitMatch[1].toLowerCase())) {
-        descriptor = unitMatch[1];
-        working = working.slice(unitMatch[0].length).trim();
+};
+
+// src/profiles/schedulable.schema.json
+var schedulable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/schedulable",
+  title: "Soustack Schedulable Profile Schema",
+  description: "Extends the base schema to ensure every instruction is fully scheduled.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      properties: {
+        instructions: {
+          type: "array",
+          items: {
+            anyOf: [
+              { $ref: "#/definitions/schedulableInstruction" },
+              { $ref: "#/definitions/schedulableInstructionSubsection" }
+            ]
+          }
+        }
       }
     }
+  ],
+  definitions: {
+    schedulableInstruction: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instruction" },
+        { required: ["id", "timing"] }
+      ]
+    },
+    schedulableInstructionSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instructionSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              items: { $ref: "#/definitions/schedulableInstruction" }
+            }
+          }
+        }
+      ]
+    }
   }
-  return {
-    amount,
-    unit,
-    descriptor,
-    remainder: working.trim(),
-    notes,
-    originalAmount
+};
+
+// src/validator.ts
+var profileSchemas = {
+  base: base_schema_default,
+  cookable: cookable_schema_default,
+  scalable: base_schema_default,
+  quantified: quantified_schema_default,
+  illustrated: illustrated_schema_default,
+  schedulable: schedulable_schema_default
+};
+var validationContexts = /* @__PURE__ */ new Map();
+function createContext(collectAllErrors) {
+  const ajv = new Ajv({ strict: false, allErrors: collectAllErrors });
+  addFormats(ajv);
+  const loadedIds = /* @__PURE__ */ new Set();
+  const addSchemaIfNew = (schema) => {
+    if (!schema) return;
+    const schemaId = schema == null ? void 0 : schema.$id;
+    if (schemaId && loadedIds.has(schemaId)) return;
+    ajv.addSchema(schema);
+    if (schemaId) loadedIds.add(schemaId);
   };
+  addSchemaIfNew(schema_default);
+  addSchemaIfNew(soustack_schema_default);
+  Object.values(profileSchemas).forEach(addSchemaIfNew);
+  return { ajv, validators: {} };
 }
-function parseNumber(value) {
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  if (/^\d+\s+\d+\/\d+$/.test(trimmed)) {
-    const [whole, fraction] = trimmed.split(/\s+/);
-    return parseInt(whole, 10) + parseFraction(fraction);
-  }
-  if (/^\d+\/\d+$/.test(trimmed)) {
-    return parseFraction(trimmed);
+function getContext(collectAllErrors) {
+  if (!validationContexts.has(collectAllErrors)) {
+    validationContexts.set(collectAllErrors, createContext(collectAllErrors));
   }
-  const parsed = Number(trimmed);
-  return Number.isNaN(parsed) ? null : parsed;
+  return validationContexts.get(collectAllErrors);
 }
-function parseFraction(value) {
-  const [numerator, denominator] = value.split("/").map(Number);
-  if (!denominator) return numerator;
-  return numerator / denominator;
-}
-function normalizeUnit(raw) {
-  const lower = raw.toLowerCase();
-  if (UNIT_SYNONYMS[lower]) {
-    return UNIT_SYNONYMS[lower];
+function cloneRecipe(recipe) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(recipe);
   }
-  if (raw === "T") return "tbsp";
-  if (raw === "t") return "tsp";
-  if (raw === "C") return "cup";
-  return null;
+  return JSON.parse(JSON.stringify(recipe));
 }
-function mergeQuantities(extracted, measurement) {
-  const quantity = {
-    amount: extracted.amount ?? null,
-    unit: extracted.unit ?? null
-  };
-  if (!measurement) {
-    return { quantity, usedParenthetical: false };
-  }
-  const measurementUnit = measurement.unit?.toLowerCase() ?? null;
-  const shouldPrefer = !quantity.unit || measurementUnit !== null && WEIGHT_PRIORITY_UNITS.has(measurementUnit);
-  if (shouldPrefer) {
-    return {
-      quantity: {
-        amount: measurement.amount,
-        unit: measurement.unit ?? null
-      },
-      usedParenthetical: true
-    };
+function detectProfileFromSchema(schemaRef) {
+  if (!schemaRef) return void 0;
+  const match = schemaRef.match(/\/profiles\/([a-z]+)\.schema\.json$/i);
+  if (match) {
+    const profile = match[1].toLowerCase();
+    if (profile in profileSchemas) return profile;
   }
-  return { quantity, usedParenthetical: false };
-}
-function extractNameAndPrep(value) {
-  let working = value.trim();
-  const notes = [];
-  let prep;
-  const lastComma = working.lastIndexOf(",");
-  if (lastComma >= 0) {
-    const trailing = working.slice(lastComma + 1).trim();
-    if (isPrepPhrase(trailing)) {
-      prep = trailing;
-      working = working.slice(0, lastComma).trim();
+  return void 0;
+}
+function getValidator(profile, context) {
+  if (!profileSchemas[profile]) {
+    throw new Error(`Unknown Soustack profile: ${profile}`);
+  }
+  if (!context.validators[profile]) {
+    context.validators[profile] = context.ajv.compile(profileSchemas[profile]);
+  }
+  return context.validators[profile];
+}
+function normalizeRecipe(recipe) {
+  const normalized = cloneRecipe(recipe);
+  const warnings = [];
+  normalizeTime(normalized);
+  if (normalized && typeof normalized === "object" && "version" in normalized && !normalized.recipeVersion && typeof normalized.version === "string") {
+    normalized.recipeVersion = normalized.version;
+    warnings.push({ path: "/version", message: "'version' is deprecated; mapped to 'recipeVersion'." });
+  }
+  return { normalized, warnings };
+}
+function normalizeTime(recipe) {
+  const time = recipe == null ? void 0 : recipe.time;
+  if (!time || typeof time !== "object" || Array.isArray(time)) return;
+  const structuredKeys = [
+    "prep",
+    "active",
+    "passive",
+    "total"
+  ];
+  structuredKeys.forEach((key) => {
+    const value = time[key];
+    if (typeof value === "number") return;
+    const parsed = parseDuration(value);
+    if (parsed !== null) {
+      time[key] = parsed;
     }
+  });
+}
+var _a, _b;
+var allowedTopLevelProps = /* @__PURE__ */ new Set([
+  ...Object.keys((_b = (_a = soustack_schema_default) == null ? void 0 : _a.properties) != null ? _b : {}),
+  "metadata",
+  "$schema"
+]);
+function detectUnknownTopLevelKeys(recipe) {
+  if (!recipe || typeof recipe !== "object") return [];
+  const disallowedKeys = Object.keys(recipe).filter(
+    (key) => !allowedTopLevelProps.has(key) && !key.startsWith("x-")
+  );
+  return disallowedKeys.map((key) => ({
+    path: `/${key}`,
+    keyword: "additionalProperties",
+    message: `Unknown top-level property '${key}' is not allowed by the Soustack spec`
+  }));
+}
+function formatAjvError(error) {
+  var _a2;
+  let path = error.instancePath || "/";
+  if (error.keyword === "additionalProperties" && ((_a2 = error.params) == null ? void 0 : _a2.additionalProperty)) {
+    const extra = error.params.additionalProperty;
+    path = `${error.instancePath || ""}/${extra}`.replace(/\/+/g, "/") || "/";
   }
-  working = working.replace(/^[,.\s-]+/, "").trim();
-  working = working.replace(/^of\s+/i, "").trim();
-  if (!working) {
-    return { name: void 0, prep, notes };
-  }
-  let name = cleanupIngredientName(working);
   return {
-    name: name || void 0,
-    prep,
-    notes
+    path,
+    keyword: error.keyword,
+    message: error.message || "Validation error"
   };
 }
-function cleanupIngredientName(value) {
-  let result = value.trim();
-  if (/^cans?\b/i.test(result)) {
-    result = result.replace(/^cans?\b/i, "canned").trim();
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    if (/^of\s+/i.test(result)) {
-      result = result.replace(/^of\s+/i, "").trim();
-      changed = true;
-      continue;
+function runAjvValidation(data, profile, context, schemaRef) {
+  const validator = schemaRef ? context.ajv.getSchema(schemaRef) : void 0;
+  const validateFn = validator != null ? validator : getValidator(profile, context);
+  const isValid = validateFn(data);
+  return !isValid && validateFn.errors ? validateFn.errors.map(formatAjvError) : [];
+}
+function isInstruction(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && "text" in item;
+}
+function isInstructionSubsection(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && "items" in item && "subsection" in item;
+}
+function checkInstructionGraph(recipe) {
+  const instructions = recipe == null ? void 0 : recipe.instructions;
+  if (!Array.isArray(instructions)) return [];
+  const instructionIds = /* @__PURE__ */ new Set();
+  const dependencyRefs = [];
+  const collect = (items, basePath) => {
+    items.forEach((item, index) => {
+      const currentPath = `${basePath}/${index}`;
+      if (isInstructionSubsection(item) && Array.isArray(item.items)) {
+        collect(item.items, `${currentPath}/items`);
+        return;
+      }
+      if (isInstruction(item)) {
+        const id = typeof item.id === "string" ? item.id : void 0;
+        if (id) instructionIds.add(id);
+        if (Array.isArray(item.dependsOn)) {
+          item.dependsOn.forEach((depId, depIndex) => {
+            if (typeof depId === "string") {
+              dependencyRefs.push({
+                fromId: id,
+                toId: depId,
+                path: `${currentPath}/dependsOn/${depIndex}`
+              });
+            }
+          });
+        }
+      }
+    });
+  };
+  collect(instructions, "/instructions");
+  const errors = [];
+  dependencyRefs.forEach((ref) => {
+    if (!instructionIds.has(ref.toId)) {
+      errors.push({
+        path: ref.path,
+        message: `Instruction dependency references missing id '${ref.toId}'.`
+      });
     }
-    const match = result.match(/^(clove|cloves|sprig|sprigs|bunch|bunches|stick|sticks|slice|slices)\b/i);
-    if (match) {
-      result = result.slice(match[0].length).trim();
-      changed = true;
+  });
+  const adjacency = /* @__PURE__ */ new Map();
+  dependencyRefs.forEach((ref) => {
+    var _a2;
+    if (ref.fromId && instructionIds.has(ref.fromId) && instructionIds.has(ref.toId)) {
+      const list = (_a2 = adjacency.get(ref.fromId)) != null ? _a2 : [];
+      list.push({ toId: ref.toId, path: ref.path });
+      adjacency.set(ref.fromId, list);
     }
-  }
-  return result;
-}
-function isPrepPhrase(value) {
-  const normalized = value.toLowerCase();
-  return PREP_PHRASES.includes(normalized);
-}
-function inferScaling(name, unit, amount, notes, descriptor) {
-  const lowerName = name?.toLowerCase() ?? "";
-  const normalizedNotes = notes.map((note) => note.toLowerCase());
-  const descriptorLower = descriptor?.toLowerCase();
-  if (lowerName.includes("egg") || descriptorLower === "clove" || descriptorLower === "cloves" || normalizedNotes.some((note) => note.includes("clove"))) {
-    return { type: "discrete", roundTo: 1 };
-  }
-  if (descriptorLower === "stick" || descriptorLower === "sticks") {
-    return { type: "discrete", roundTo: 1 };
-  }
-  if (normalizedNotes.some((note) => PURPOSE_KEYWORDS.some((keyword) => note.includes(keyword)))) {
-    return { type: "fixed" };
-  }
-  const isSpice = SPICE_KEYWORDS.some((keyword) => lowerName.includes(keyword));
-  const smallUnit = unit ? ["tsp", "tbsp", "dash", "pinch"].includes(unit) : false;
-  if (normalizedNotes.some((note) => note.includes("to taste")) || isSpice && (smallUnit || amount !== null && amount <= 1)) {
-    return { type: "proportional", factor: 0.7 };
-  }
-  return { type: "linear" };
-}
-function formatNotes(notes) {
-  const cleaned = Array.from(
-    new Set(
-      notes.map((note) => note.trim()).filter(Boolean)
-    )
-  );
-  return cleaned.length ? cleaned.join("; ") : void 0;
-}
-function formatCountNote(amount, descriptor) {
-  const lower = descriptor.toLowerCase();
-  const singular = lower.endsWith("s") ? lower.slice(0, -1) : lower;
-  const word = amount === 1 ? singular : singular.endsWith("ch") || singular.endsWith("sh") || singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") ? `${singular}es` : singular.endsWith("y") && !/[aeiou]y$/.test(singular) ? `${singular.slice(0, -1)}ies` : `${singular}s`;
-  return `${formatDecimal(amount)} ${word}`;
-}
-function singularize(value) {
-  const trimmed = value.trim();
-  if (trimmed.endsWith("ies")) {
-    return `${trimmed.slice(0, -3)}y`;
-  }
-  if (/(ches|shes|sses|xes|zes)$/i.test(trimmed)) {
-    return trimmed.slice(0, -2);
-  }
-  if (trimmed.endsWith("s")) {
-    return trimmed.slice(0, -1);
-  }
-  return trimmed;
-}
-
-// src/converters/ingredient.ts
-function parseIngredientLine2(line) {
-  const parsed = parseIngredient(line);
-  const ingredient = {
-    item: parsed.item,
-    scaling: parsed.scaling ?? { type: "linear" }
+  });
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const detectCycles = (nodeId) => {
+    var _a2;
+    if (visiting.has(nodeId)) return;
+    if (visited.has(nodeId)) return;
+    visiting.add(nodeId);
+    const neighbors = (_a2 = adjacency.get(nodeId)) != null ? _a2 : [];
+    neighbors.forEach((edge) => {
+      if (visiting.has(edge.toId)) {
+        errors.push({
+          path: edge.path,
+          message: `Circular dependency detected involving instruction id '${edge.toId}'.`
+        });
+        return;
+      }
+      detectCycles(edge.toId);
+    });
+    visiting.delete(nodeId);
+    visited.add(nodeId);
   };
-  if (parsed.name) {
-    ingredient.name = parsed.name;
-  }
-  if (parsed.prep) {
-    ingredient.prep = parsed.prep;
-  }
-  if (parsed.optional) {
-    ingredient.optional = true;
-  }
-  if (parsed.notes) {
-    ingredient.notes = parsed.notes;
-  }
-  const quantity = buildQuantity(parsed.quantity);
-  if (quantity) {
-    ingredient.quantity = quantity;
-  }
-  return ingredient;
-}
-function buildQuantity(parsedQuantity) {
-  if (!parsedQuantity) {
-    return void 0;
-  }
-  if (parsedQuantity.amount === null || Number.isNaN(parsedQuantity.amount)) {
-    return void 0;
-  }
+  instructionIds.forEach((id) => detectCycles(id));
+  return errors;
+}
+function validateRecipe(input, options = {}) {
+  var _a2, _b2, _c, _d;
+  const collectAllErrors = (_a2 = options.collectAllErrors) != null ? _a2 : true;
+  const context = getContext(collectAllErrors);
+  const schemaRef = (_b2 = options.schema) != null ? _b2 : typeof (input == null ? void 0 : input.$schema) === "string" ? input.$schema : void 0;
+  const profile = (_d = (_c = options.profile) != null ? _c : detectProfileFromSchema(schemaRef)) != null ? _d : "base";
+  const { normalized, warnings } = normalizeRecipe(input);
+  const unknownKeyErrors = detectUnknownTopLevelKeys(normalized);
+  const validationErrors = runAjvValidation(normalized, profile, context, schemaRef);
+  const graphErrors = profile === "schedulable" && validationErrors.length === 0 ? checkInstructionGraph(normalized) : [];
+  const errors = [...unknownKeyErrors, ...validationErrors, ...graphErrors];
   return {
-    amount: parsedQuantity.amount,
-    unit: parsedQuantity.unit ?? null
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    normalized: errors.length === 0 ? normalized : void 0
   };
 }
+function detectProfiles(recipe) {
+  var _a2;
+  const result = validateRecipe(recipe, { profile: "base", collectAllErrors: false });
+  if (!result.valid) return [];
+  const normalizedRecipe = (_a2 = result.normalized) != null ? _a2 : recipe;
+  const profiles = ["base"];
+  const context = getContext(false);
+  Object.keys(profileSchemas).forEach((profile) => {
+    if (profile === "base") return;
+    if (!profileSchemas[profile]) return;
+    const errors = runAjvValidation(normalizedRecipe, profile, context);
+    if (errors.length === 0) {
+      profiles.push(profile);
+    }
+  });
+  return profiles;
+}
 
 // src/converters/yield.ts
 function parseYield(value) {
@@ -1121,128 +1343,48 @@ function parseYield(value) {
     return void 0;
   }
   if (typeof value === "number") {
-    return {
-      amount: value,
-      unit: "servings"
-    };
-  }
-  if (Array.isArray(value)) {
-    return parseYield(value[0]);
-  }
-  if (typeof value === "object") {
-    const maybeYield = value;
-    if (typeof maybeYield.amount === "number") {
-      return {
-        amount: maybeYield.amount,
-        unit: typeof maybeYield.unit === "string" ? maybeYield.unit : "servings",
-        description: typeof maybeYield.description === "string" ? maybeYield.description : void 0
-      };
-    }
-  }
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    const match = trimmed.match(/(\d+(?:\.\d+)?)/);
-    if (match) {
-      const amount = parseFloat(match[1]);
-      const unit = trimmed.slice(match.index + match[1].length).trim();
-      return {
-        amount,
-        unit: unit || "servings",
-        description: trimmed
-      };
-    }
-  }
-  return void 0;
-}
-function formatYield(yieldValue) {
-  if (!yieldValue) return void 0;
-  if (!yieldValue.amount && !yieldValue.unit) {
-    return void 0;
-  }
-  const amount = yieldValue.amount ?? "";
-  const unit = yieldValue.unit ? ` ${yieldValue.unit}` : "";
-  return `${amount}${unit}`.trim() || yieldValue.description;
-}
-
-// src/parsers/duration.ts
-var ISO_DURATION_REGEX = /^P(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/i;
-var HUMAN_OVERNIGHT = 8 * 60;
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function parseDuration(iso) {
-  if (!iso || typeof iso !== "string") return null;
-  const trimmed = iso.trim();
-  if (!trimmed) return null;
-  const match = trimmed.match(ISO_DURATION_REGEX);
-  if (!match) return null;
-  const [, daysRaw, hoursRaw, minutesRaw, secondsRaw] = match;
-  if (!daysRaw && !hoursRaw && !minutesRaw && !secondsRaw) {
-    return null;
-  }
-  let total = 0;
-  if (daysRaw) total += parseFloat(daysRaw) * 24 * 60;
-  if (hoursRaw) total += parseFloat(hoursRaw) * 60;
-  if (minutesRaw) total += parseFloat(minutesRaw);
-  if (secondsRaw) total += Math.ceil(parseFloat(secondsRaw) / 60);
-  return Math.round(total);
-}
-function formatDuration(minutes) {
-  if (!isFiniteNumber(minutes) || minutes <= 0) {
-    return "PT0M";
-  }
-  const rounded = Math.round(minutes);
-  const days = Math.floor(rounded / (24 * 60));
-  const afterDays = rounded % (24 * 60);
-  const hours = Math.floor(afterDays / 60);
-  const mins = afterDays % 60;
-  let result = "P";
-  if (days > 0) {
-    result += `${days}D`;
-  }
-  if (hours > 0 || mins > 0) {
-    result += "T";
-    if (hours > 0) {
-      result += `${hours}H`;
-    }
-    if (mins > 0) {
-      result += `${mins}M`;
-    }
-  }
-  if (result === "P") {
-    return "PT0M";
-  }
-  return result;
-}
-function parseHumanDuration(text) {
-  if (!text || typeof text !== "string") return null;
-  const normalized = text.toLowerCase().trim();
-  if (!normalized) return null;
-  if (normalized === "overnight") {
-    return HUMAN_OVERNIGHT;
+    return {
+      amount: value,
+      unit: "servings"
+    };
   }
-  let total = 0;
-  const hourRegex = /(\d+(?:\.\d+)?)\s*(?:hours?|hrs?|hr|h)\b/g;
-  let hourMatch;
-  while ((hourMatch = hourRegex.exec(normalized)) !== null) {
-    total += parseFloat(hourMatch[1]) * 60;
+  if (Array.isArray(value)) {
+    return parseYield(value[0]);
   }
-  const minuteRegex = /(\d+(?:\.\d+)?)\s*(?:minutes?|mins?|min|m)\b/g;
-  let minuteMatch;
-  while ((minuteMatch = minuteRegex.exec(normalized)) !== null) {
-    total += parseFloat(minuteMatch[1]);
+  if (typeof value === "object") {
+    const maybeYield = value;
+    if (typeof maybeYield.amount === "number") {
+      return {
+        amount: maybeYield.amount,
+        unit: typeof maybeYield.unit === "string" ? maybeYield.unit : "servings",
+        description: typeof maybeYield.description === "string" ? maybeYield.description : void 0
+      };
+    }
   }
-  if (total <= 0) {
-    return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const match = trimmed.match(/(\d+(?:\.\d+)?)/);
+    if (match) {
+      const amount = parseFloat(match[1]);
+      const unit = trimmed.slice(match.index + match[1].length).trim();
+      return {
+        amount,
+        unit: unit || "servings",
+        description: trimmed
+      };
+    }
   }
-  return Math.round(total);
+  return void 0;
 }
-function smartParseDuration(input) {
-  const iso = parseDuration(input);
-  if (iso !== null) {
-    return iso;
+function formatYield(yieldValue) {
+  var _a2;
+  if (!yieldValue) return void 0;
+  if (!yieldValue.amount && !yieldValue.unit) {
+    return void 0;
   }
-  return parseHumanDuration(input);
+  const amount = (_a2 = yieldValue.amount) != null ? _a2 : "";
+  const unit = yieldValue.unit ? ` ${yieldValue.unit}` : "";
+  return `${amount}${unit}`.trim() || yieldValue.description;
 }
 
 // src/utils/image.ts
@@ -1281,6 +1423,7 @@ function extractUrl(value) {
 
 // src/fromSchemaOrg.ts
 function fromSchemaOrg(input) {
+  var _a2;
   const recipeNode = extractRecipeNode(input);
   if (!recipeNode) {
     return null;
@@ -1295,7 +1438,7 @@ function fromSchemaOrg(input) {
   const nutrition = recipeNode.nutrition && typeof recipeNode.nutrition === "object" ? recipeNode.nutrition : void 0;
   return {
     name: recipeNode.name.trim(),
-    description: recipeNode.description?.trim() || void 0,
+    description: ((_a2 = recipeNode.description) == null ? void 0 : _a2.trim()) || void 0,
     image: normalizeImage(recipeNode.image),
     category,
     tags: tags.length ? tags : void 0,
@@ -1341,8 +1484,6 @@ function extractRecipeNode(input) {
 function hasRecipeType(value) {
   if (!value) return false;
   const types = Array.isArray(value) ? value : [value];
-  fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "fromSchemaOrg.ts:95", message: "hasRecipeType check", data: { types, typesLower: types.map((t) => typeof t === "string" ? t.toLowerCase() : t), isMatch: types.some((e) => typeof e === "string" && e.toLowerCase() === "recipe") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
-  });
   return types.some(
     (entry) => typeof entry === "string" && entry.toLowerCase() === "recipe"
   );
@@ -1353,9 +1494,10 @@ function isValidName(name) {
 function convertIngredients(value) {
   if (!value) return [];
   const normalized = Array.isArray(value) ? value : [value];
-  return normalized.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean).map((line) => parseIngredientLine2(line));
+  return normalized.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
 }
 function convertInstructions(value) {
+  var _a2;
   if (!value) return [];
   const normalized = Array.isArray(value) ? value : [value];
   const result = [];
@@ -1372,7 +1514,7 @@ function convertInstructions(value) {
       const subsectionItems = extractSectionItems(entry.itemListElement);
       if (subsectionItems.length) {
         result.push({
-          subsection: entry.name?.trim() || "Section",
+          subsection: ((_a2 = entry.name) == null ? void 0 : _a2.trim()) || "Section",
           items: subsectionItems
         });
       }
@@ -1421,10 +1563,33 @@ function convertHowToStep(step) {
     return void 0;
   }
   const normalizedImage = normalizeImage(step.image);
-  if (typeof normalizedImage === "string") {
-    return { text, image: normalizedImage };
+  const image = Array.isArray(normalizedImage) ? normalizedImage[0] : normalizedImage;
+  const id = extractInstructionId(step);
+  const timing = extractInstructionTiming(step);
+  if (!image && !id && !timing) {
+    return text;
+  }
+  const instruction = { text };
+  if (id) instruction.id = id;
+  if (image) instruction.image = image;
+  if (timing) instruction.timing = timing;
+  return instruction;
+}
+function extractInstructionTiming(step) {
+  const duration = step.totalTime || step.performTime || step.prepTime || step.duration;
+  if (!duration || typeof duration !== "string") {
+    return void 0;
+  }
+  const parsed = smartParseDuration(duration);
+  return { duration: parsed != null ? parsed : duration, type: "active" };
+}
+function extractInstructionId(step) {
+  const raw = step["@id"] || step.id || step.url;
+  if (typeof raw !== "string") {
+    return void 0;
   }
-  return text;
+  const trimmed = raw.trim();
+  return trimmed || void 0;
 }
 function isHowToStep(value) {
   return Boolean(value) && typeof value === "object" && value["@type"] === "HowToStep";
@@ -1433,9 +1598,10 @@ function isHowToSection(value) {
   return Boolean(value) && typeof value === "object" && value["@type"] === "HowToSection" && Array.isArray(value.itemListElement);
 }
 function convertTime(recipe) {
-  const prep = smartParseDuration(recipe.prepTime ?? "");
-  const cook = smartParseDuration(recipe.cookTime ?? "");
-  const total = smartParseDuration(recipe.totalTime ?? "");
+  var _a2, _b2, _c;
+  const prep = smartParseDuration((_a2 = recipe.prepTime) != null ? _a2 : "");
+  const cook = smartParseDuration((_b2 = recipe.cookTime) != null ? _b2 : "");
+  const total = smartParseDuration((_c = recipe.totalTime) != null ? _c : "");
   const structured = {};
   if (prep !== null && prep !== void 0) structured.prep = prep;
   if (cook !== null && cook !== void 0) structured.active = cook;
@@ -1468,9 +1634,10 @@ function extractFirst(value) {
   return arr.length ? arr[0] : void 0;
 }
 function convertSource(recipe) {
+  var _a2;
   const author = extractEntityName(recipe.author);
   const publisher = extractEntityName(recipe.publisher);
-  const url = (recipe.url || recipe.mainEntityOfPage)?.trim();
+  const url = (_a2 = recipe.url || recipe.mainEntityOfPage) == null ? void 0 : _a2.trim();
   const source = {};
   if (author) source.author = author;
   if (publisher) source.name = publisher;
@@ -1501,13 +1668,14 @@ function extractEntityName(value) {
 
 // src/converters/toSchemaOrg.ts
 function convertBasicMetadata(recipe) {
+  var _a2;
   return cleanOutput({
     "@context": "https://schema.org",
     "@type": "Recipe",
     name: recipe.name,
     description: recipe.description,
     image: recipe.image,
-    url: recipe.source?.url,
+    url: (_a2 = recipe.source) == null ? void 0 : _a2.url,
     datePublished: recipe.dateAdded,
     dateModified: recipe.dateModified
   });
@@ -1515,6 +1683,7 @@ function convertBasicMetadata(recipe) {
 function convertIngredients2(ingredients = []) {
   const result = [];
   ingredients.forEach((ingredient) => {
+    var _a2;
     if (!ingredient) {
       return;
     }
@@ -1544,7 +1713,7 @@ function convertIngredients2(ingredients = []) {
       });
       return;
     }
-    const value = ingredient.item?.trim();
+    const value = (_a2 = ingredient.item) == null ? void 0 : _a2.trim();
     if (value) {
       result.push(value);
     }
@@ -1559,10 +1728,11 @@ function convertInstruction(entry) {
     return null;
   }
   if (typeof entry === "string") {
-    return createHowToStep(entry);
+    const value = entry.trim();
+    return value || null;
   }
   if ("subsection" in entry) {
-    const steps = entry.items.map((item) => createHowToStep(item)).filter((step) => Boolean(step));
+    const steps = entry.items.map((item) => convertInstruction(item)).filter((step) => Boolean(step));
     if (!steps.length) {
       return null;
     }
@@ -1578,18 +1748,13 @@ function convertInstruction(entry) {
   return createHowToStep(String(entry));
 }
 function createHowToStep(entry) {
+  var _a2;
   if (!entry) return null;
   if (typeof entry === "string") {
     const trimmed2 = entry.trim();
-    if (!trimmed2) {
-      return null;
-    }
-    return {
-      "@type": "HowToStep",
-      text: trimmed2
-    };
+    return trimmed2 || null;
   }
-  const trimmed = entry.text?.trim();
+  const trimmed = (_a2 = entry.text) == null ? void 0 : _a2.trim();
   if (!trimmed) {
     return null;
   }
@@ -1597,10 +1762,23 @@ function createHowToStep(entry) {
     "@type": "HowToStep",
     text: trimmed
   };
+  if (entry.id) {
+    step["@id"] = entry.id;
+  }
+  if (entry.timing) {
+    if (typeof entry.timing.duration === "number") {
+      step.performTime = formatDuration(entry.timing.duration);
+    } else if (entry.timing.duration) {
+      step.performTime = entry.timing.duration;
+    }
+  }
   if (entry.image) {
     step.image = entry.image;
   }
-  return step;
+  if (step["@id"] || step.performTime || step.image) {
+    return step;
+  }
+  return trimmed;
 }
 function convertTime2(time) {
   if (!time) {
@@ -1700,113 +1878,6 @@ function isStructuredTime(time) {
   return typeof time.prep !== "undefined" || typeof time.active !== "undefined" || typeof time.passive !== "undefined" || typeof time.total !== "undefined";
 }
 
-// src/scraper/fetch.ts
-var DEFAULT_USER_AGENTS = [
-  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0"
-];
-function chooseUserAgent(provided) {
-  if (provided) return provided;
-  const index = Math.floor(Math.random() * DEFAULT_USER_AGENTS.length);
-  return DEFAULT_USER_AGENTS[index];
-}
-function resolveFetch(fetchFn) {
-  if (fetchFn) {
-    return fetchFn;
-  }
-  const globalFetch = globalThis.fetch;
-  if (!globalFetch) {
-    throw new Error(
-      "A global fetch implementation is not available. Provide window.fetch in browsers or upgrade to Node 18+."
-    );
-  }
-  return globalFetch;
-}
-function isBrowserEnvironment() {
-  return typeof globalThis.document !== "undefined";
-}
-function isClientError(error) {
-  if (typeof error.status === "number") {
-    return error.status >= 400 && error.status < 500;
-  }
-  return error.message.includes("HTTP 4");
-}
-async function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function fetchPage(url, options = {}) {
-  const {
-    timeout = 1e4,
-    userAgent,
-    maxRetries = 2,
-    fetchFn
-  } = options;
-  let lastError = null;
-  const resolvedFetch = resolveFetch(fetchFn);
-  const isBrowser2 = isBrowserEnvironment();
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const headers = {
-        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.5"
-      };
-      if (!isBrowser2) {
-        headers["User-Agent"] = chooseUserAgent(userAgent);
-      }
-      const requestInit = {
-        headers,
-        signal: controller.signal,
-        redirect: "follow"
-      };
-      const response = await resolvedFetch(url, requestInit);
-      clearTimeout(timeoutId);
-      if (response && typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-        try {
-          const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-          if (globalFetch) {
-            globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/fetch.ts:63", message: "fetch response", data: { url, status: response.status, statusText: response.statusText, ok: response.ok, isNYTimes: url.includes("nytimes.com") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
-            });
-          }
-        } catch {
-        }
-      }
-      if (!response.ok) {
-        const error = new Error(
-          `HTTP ${response.status}: ${response.statusText}`
-        );
-        error.status = response.status;
-        throw error;
-      }
-      const html = await response.text();
-      if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-        try {
-          const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-          if (globalFetch) {
-            globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/fetch.ts:75", message: "HTML received", data: { htmlLength: html.length, hasLoginPage: html.toLowerCase().includes("login") || html.toLowerCase().includes("sign in"), hasRecipeData: html.includes("application/ld+json") || html.includes("schema.org/Recipe") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B,D" }) }).catch(() => {
-            });
-          }
-        } catch {
-        }
-      }
-      return html;
-    } catch (err) {
-      clearTimeout(timeoutId);
-      lastError = err instanceof Error ? err : new Error(String(err));
-      if (isClientError(lastError)) {
-        throw lastError;
-      }
-      if (attempt < maxRetries) {
-        await wait(1e3 * (attempt + 1));
-        continue;
-      }
-    }
-  }
-  throw lastError ?? new Error("Failed to fetch page");
-}
-
 // src/scraper/extractors/utils.ts
 var RECIPE_TYPES = /* @__PURE__ */ new Set([
   "recipe",
@@ -1843,97 +1914,8 @@ function normalizeText(value) {
   return trimmed || void 0;
 }
 
-// src/scraper/extractors/jsonld.ts
-function extractJsonLd(html) {
-  const $ = load(html);
-  const scripts = $('script[type="application/ld+json"]');
-  fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/jsonld.ts:8", message: "JSON-LD scripts found", data: { scriptCount: scripts.length }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
-  });
-  const candidates = [];
-  scripts.each((_, element) => {
-    const content = $(element).html();
-    if (!content) return;
-    const parsed = safeJsonParse(content);
-    if (!parsed) return;
-    fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/jsonld.ts:18", message: "JSON-LD parsed", data: { hasGraph: !!(parsed && typeof parsed === "object" && "@graph" in parsed), type: parsed && typeof parsed === "object" && "@type" in parsed ? parsed["@type"] : void 0 }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C" }) }).catch(() => {
-    });
-    collectCandidates(parsed, candidates);
-  });
-  fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/jsonld.ts:22", message: "JSON-LD candidates", data: { candidateCount: candidates.length, candidateTypes: candidates.map((c) => c["@type"]) }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C" }) }).catch(() => {
-  });
-  return candidates[0] ?? null;
-}
-function collectCandidates(payload, bucket) {
-  if (!payload) return;
-  if (Array.isArray(payload)) {
-    payload.forEach((entry) => collectCandidates(entry, bucket));
-    return;
-  }
-  if (typeof payload !== "object") {
-    return;
-  }
-  if (isRecipeNode(payload)) {
-    bucket.push(payload);
-    return;
-  }
-  const graph = payload["@graph"];
-  if (Array.isArray(graph)) {
-    graph.forEach((entry) => collectCandidates(entry, bucket));
-  }
-}
-var SIMPLE_PROPS = [
-  "name",
-  "description",
-  "image",
-  "recipeYield",
-  "prepTime",
-  "cookTime",
-  "totalTime"
-];
-function extractMicrodata(html) {
-  const $ = load(html);
-  const recipeEl = $('[itemscope][itemtype*="schema.org/Recipe"]').first();
-  if (!recipeEl.length) {
-    return null;
-  }
-  const recipe = {
-    "@type": "Recipe"
-  };
-  SIMPLE_PROPS.forEach((prop) => {
-    const value = findPropertyValue($, recipeEl, prop);
-    if (value) {
-      recipe[prop] = value;
-    }
-  });
-  const ingredients = [];
-  recipeEl.find('[itemprop="recipeIngredient"]').each((_, el) => {
-    const text = normalizeText($(el).attr("content") || $(el).text());
-    if (text) ingredients.push(text);
-  });
-  if (ingredients.length) {
-    recipe.recipeIngredient = ingredients;
-  }
-  const instructions = [];
-  recipeEl.find('[itemprop="recipeInstructions"]').each((_, el) => {
-    const text = normalizeText($(el).attr("content")) || normalizeText($(el).find('[itemprop="text"]').first().text()) || normalizeText($(el).text());
-    if (text) instructions.push(text);
-  });
-  if (instructions.length) {
-    recipe.recipeInstructions = instructions;
-  }
-  if (recipe.name || ingredients.length) {
-    return recipe;
-  }
-  return null;
-}
-function findPropertyValue($, context, prop) {
-  const node = context.find(`[itemprop="${prop}"]`).first();
-  if (!node.length) return void 0;
-  return normalizeText(node.attr("content")) || normalizeText(node.attr("href")) || normalizeText(node.attr("src")) || normalizeText(node.text());
-}
-
 // src/scraper/extractors/browser.ts
-var SIMPLE_PROPS2 = ["name", "description", "image", "recipeYield", "prepTime", "cookTime", "totalTime"];
+var SIMPLE_PROPS = ["name", "description", "image", "recipeYield", "prepTime", "cookTime", "totalTime"];
 function extractRecipeBrowser(html) {
   const jsonLdRecipe = extractJsonLdBrowser(html);
   if (jsonLdRecipe) {
@@ -1946,6 +1928,7 @@ function extractRecipeBrowser(html) {
   return { recipe: null, source: null };
 }
 function extractJsonLdBrowser(html) {
+  var _a2;
   if (typeof globalThis.DOMParser === "undefined") {
     return null;
   }
@@ -1958,9 +1941,9 @@ function extractJsonLdBrowser(html) {
     if (!content) return;
     const parsed = safeJsonParse(content);
     if (!parsed) return;
-    collectCandidates2(parsed, candidates);
+    collectCandidates(parsed, candidates);
   });
-  return candidates[0] ?? null;
+  return (_a2 = candidates[0]) != null ? _a2 : null;
 }
 function extractMicrodataBrowser(html) {
   if (typeof globalThis.DOMParser === "undefined") {
@@ -1975,8 +1958,8 @@ function extractMicrodataBrowser(html) {
   const recipe = {
     "@type": "Recipe"
   };
-  SIMPLE_PROPS2.forEach((prop) => {
-    const value = findPropertyValue2(recipeEl, prop);
+  SIMPLE_PROPS.forEach((prop) => {
+    const value = findPropertyValue(recipeEl, prop);
     if (value) {
       recipe[prop] = value;
     }
@@ -1993,7 +1976,8 @@ function extractMicrodataBrowser(html) {
   }
   const instructions = [];
   recipeEl.querySelectorAll('[itemprop="recipeInstructions"]').forEach((el) => {
-    const text = normalizeText(el.getAttribute("content")) || normalizeText(el.querySelector('[itemprop="text"]')?.textContent || void 0) || normalizeText(el.textContent || void 0);
+    var _a2;
+    const text = normalizeText(el.getAttribute("content")) || normalizeText(((_a2 = el.querySelector('[itemprop="text"]')) == null ? void 0 : _a2.textContent) || void 0) || normalizeText(el.textContent || void 0);
     if (text) instructions.push(text);
   });
   if (instructions.length) {
@@ -2004,15 +1988,15 @@ function extractMicrodataBrowser(html) {
   }
   return null;
 }
-function findPropertyValue2(context, prop) {
+function findPropertyValue(context, prop) {
   const node = context.querySelector(`[itemprop="${prop}"]`);
   if (!node) return void 0;
   return normalizeText(node.getAttribute("content")) || normalizeText(node.getAttribute("href")) || normalizeText(node.getAttribute("src")) || normalizeText(node.textContent || void 0);
 }
-function collectCandidates2(payload, bucket) {
+function collectCandidates(payload, bucket) {
   if (!payload) return;
   if (Array.isArray(payload)) {
-    payload.forEach((entry) => collectCandidates2(entry, bucket));
+    payload.forEach((entry) => collectCandidates(entry, bucket));
     return;
   }
   if (typeof payload !== "object") {
@@ -2024,364 +2008,19 @@ function collectCandidates2(payload, bucket) {
   }
   const graph = payload["@graph"];
   if (Array.isArray(graph)) {
-    graph.forEach((entry) => collectCandidates2(entry, bucket));
-  }
-}
-
-// src/scraper/extractors/index.ts
-function isBrowser() {
-  try {
-    return typeof globalThis.DOMParser !== "undefined";
-  } catch {
-    return false;
-  }
-}
-function extractRecipe(html) {
-  if (isBrowser()) {
-    return extractRecipeBrowser(html);
-  }
-  const jsonLdRecipe = extractJsonLd(html);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:6", message: "JSON-LD extraction result", data: { hasJsonLd: !!jsonLdRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  if (jsonLdRecipe) {
-    return { recipe: jsonLdRecipe, source: "jsonld" };
-  }
-  const microdataRecipe = extractMicrodata(html);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:12", message: "Microdata extraction result", data: { hasMicrodata: !!microdataRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "D" }) }).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  if (microdataRecipe) {
-    return { recipe: microdataRecipe, source: "microdata" };
+    graph.forEach((entry) => collectCandidates(entry, bucket));
   }
-  return { recipe: null, source: null };
 }
 
-// src/scraper/index.ts
-async function scrapeRecipe(url, options = {}) {
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:7", message: "scrapeRecipe entry", data: { url, hasOptions: !!options }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,B,C,D,E" }) }).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  const html = await fetchPage(url, options);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:9", message: "HTML fetched", data: { htmlLength: html?.length, htmlPreview: html?.substring(0, 200) }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  const { recipe } = extractRecipe(html);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:11", message: "extractRecipe result", data: { hasRecipe: !!recipe, recipeType: recipe?.["@type"], recipeName: recipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C,D" }) }).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  if (!recipe) {
-    throw new Error("No Schema.org recipe data found in page");
-  }
-  const soustackRecipe = fromSchemaOrg(recipe);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:17", message: "fromSchemaOrg result", data: { hasSoustackRecipe: !!soustackRecipe, soustackRecipeName: soustackRecipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
-        });
-      }
-    } catch {
-    }
-  }
-  if (!soustackRecipe) {
-    throw new Error("Schema.org data did not include a valid recipe");
-  }
-  return soustackRecipe;
-}
-function extractRecipeFromHTML(html) {
-  const { recipe } = extractRecipe(html);
-  if (!recipe) {
-    throw new Error("No Schema.org recipe data found in HTML");
-  }
-  const soustackRecipe = fromSchemaOrg(recipe);
-  if (!soustackRecipe) {
-    throw new Error("Schema.org data did not include a valid recipe");
-  }
-  return soustackRecipe;
-}
+// src/scraper/browser.ts
 function extractSchemaOrgRecipeFromHTML(html) {
-  const { recipe } = extractRecipe(html);
+  const { recipe } = extractRecipeBrowser(html);
   return recipe;
 }
 
-// src/parsers/yield.ts
-var RANGE_PATTERN = /^(\d+)(?:\s*(?:[-–—]|to)\s*)(\d+)\s+(.+)$/i;
-var MAKES_PREFIX = /^(makes?|yields?)\s*:?\s*(.+)$/i;
-var APPROX_PREFIX = /^(about|around|approximately|approx\.?|roughly)\s+/i;
-var SERVING_UNITS = ["servings", "serving", "portions", "portion", "people", "persons"];
-var DEFAULT_DOZEN_UNIT = "cookies";
-var NUMBER_WORDS2 = {
-  a: 1,
-  an: 1,
-  one: 1,
-  two: 2,
-  three: 3,
-  four: 4,
-  five: 5,
-  six: 6,
-  seven: 7,
-  eight: 8,
-  nine: 9,
-  ten: 10,
-  eleven: 11,
-  twelve: 12
-};
-function normalizeYield(text) {
-  if (!text || typeof text !== "string") return "";
-  return text.normalize("NFKC").replace(/\u00A0/g, " ").replace(/[–—−]/g, "-").trim().replace(/\s+/g, " ");
-}
-function parseYield2(text) {
-  const normalized = normalizeYield(text);
-  if (!normalized) return null;
-  const { main, paren } = extractParenthetical(normalized);
-  const core = parseYieldCore(main, normalized);
-  if (!core) return null;
-  const servingsFromParen = paren ? extractServingsFromParen(paren) : null;
-  if (servingsFromParen !== null) {
-    core.servings = servingsFromParen;
-    core.description = normalized;
-  }
-  if (core.servings === void 0) {
-    const inferred = inferServings(core.amount, core.unit);
-    if (inferred !== void 0) {
-      core.servings = inferred;
-    }
-  }
-  return core;
-}
-function formatYield2(value) {
-  if (value.description) {
-    return value.description;
-  }
-  if (value.servings && value.unit === "servings") {
-    return `Serves ${value.amount}`;
-  }
-  let result = `${value.amount} ${value.unit}`.trim();
-  if (value.servings && value.unit !== "servings") {
-    result += ` (${value.servings} servings)`;
-  }
-  return result;
-}
-function parseYieldCore(text, original) {
-  return parseServesPattern(text, original) ?? parseMakesPattern(text, original) ?? parseRangePattern(text, original) ?? parseNumberUnitPattern(text, original) ?? parsePlainNumberPattern(text);
-}
-function parseServesPattern(text, original) {
-  const patterns = [
-    /^serves?\s*[:\-]?\s*(\d+)(?:\s*(?:[-–—]|to)\s*(\d+))?/i,
-    /^servings?\s*[:\-]?\s*(\d+)(?:\s*(?:[-–—]|to)\s*(\d+))?/i,
-    /^serving\s*[:\-]?\s*(\d+)(?:\s*(?:[-–—]|to)\s*(\d+))?/i,
-    /^makes?\s*[:\-]?\s*(\d+)(?:\s*(?:[-–—]|to)\s*(\d+))?\s+servings?$/i,
-    /^(\d+)\s+servings?$/i
-  ];
-  for (const regex of patterns) {
-    const match = text.match(regex);
-    if (!match) continue;
-    const amount = parseInt(match[1], 10);
-    if (Number.isNaN(amount)) continue;
-    const result = {
-      amount,
-      unit: "servings",
-      servings: amount
-    };
-    if (match[2]) {
-      result.description = original;
-    }
-    return result;
-  }
-  return null;
-}
-function parseMakesPattern(text, original) {
-  const match = text.match(MAKES_PREFIX);
-  if (!match) return null;
-  const remainder = match[2].trim();
-  if (!remainder) return null;
-  const servingsMatch = remainder.match(/^(\d+)(?:\s*(?:[-–—]|to)\s*(\d+))?\s+servings?$/i);
-  if (servingsMatch) {
-    const amount = parseInt(servingsMatch[1], 10);
-    const result = {
-      amount,
-      unit: "servings",
-      servings: amount
-    };
-    if (servingsMatch[2]) {
-      result.description = original;
-    }
-    return result;
-  }
-  return parseRangePattern(remainder, original) ?? parseNumberUnitPattern(remainder, original) ?? parsePlainNumberPattern(remainder);
-}
-function parseRangePattern(text, descriptionSource) {
-  const match = text.match(RANGE_PATTERN);
-  if (!match) return null;
-  const amount = parseInt(match[1], 10);
-  const unit = cleanupUnit(match[3]);
-  if (!unit) return null;
-  const result = {
-    amount,
-    unit,
-    description: descriptionSource
-  };
-  return result;
-}
-function parseNumberUnitPattern(text, descriptionSource) {
-  if (!text) return null;
-  const { value, approximate } = stripApproximation(text);
-  if (!value) return null;
-  const dozenResult = handleDozen(value);
-  if (dozenResult) {
-    const unit = cleanupUnit(dozenResult.remainder || DEFAULT_DOZEN_UNIT);
-    const parsed = {
-      amount: dozenResult.amount,
-      unit
-    };
-    if (approximate) {
-      parsed.description = descriptionSource;
-    }
-    return parsed;
-  }
-  const numericMatch = value.match(/^(\d+(?:\.\d+)?)\s+(.+)$/);
-  if (numericMatch) {
-    const amount = parseFloat(numericMatch[1]);
-    if (!Number.isNaN(amount)) {
-      const unit = cleanupUnit(numericMatch[2]);
-      if (unit) {
-        const parsed = { amount, unit };
-        if (approximate) {
-          parsed.description = descriptionSource;
-        }
-        return parsed;
-      }
-    }
-  }
-  const wordMatch = value.match(/^([a-zA-Z]+)\s+(.+)$/);
-  if (wordMatch) {
-    const amount = wordToNumber(wordMatch[1]);
-    if (amount !== null) {
-      const unit = cleanupUnit(wordMatch[2]);
-      if (unit) {
-        const parsed = { amount, unit };
-        if (approximate) {
-          parsed.description = descriptionSource;
-        }
-        return parsed;
-      }
-    }
-  }
-  return null;
-}
-function parsePlainNumberPattern(text) {
-  const match = text.match(/^(\d+)$/);
-  if (!match) return null;
-  const amount = parseInt(match[1], 10);
-  if (Number.isNaN(amount)) return null;
-  return {
-    amount,
-    unit: "servings",
-    servings: amount
-  };
-}
-function stripApproximation(value) {
-  const match = value.match(APPROX_PREFIX);
-  if (!match) {
-    return { value: value.trim(), approximate: false };
-  }
-  const stripped = value.slice(match[0].length).trim();
-  return { value: stripped, approximate: true };
-}
-function handleDozen(text) {
-  const match = text.match(
-    /^((?:\d+(?:\.\d+)?)|(?:one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|a|an|half))\s+dozens?\b(.*)$/i
-  );
-  if (!match) return null;
-  const token = match[1].toLowerCase();
-  let multiplier = null;
-  if (token === "half") {
-    multiplier = 0.5;
-  } else if (!Number.isNaN(Number(token))) {
-    multiplier = parseFloat(token);
-  } else {
-    multiplier = wordToNumber(token);
-  }
-  if (multiplier === null) return null;
-  const amount = multiplier * 12;
-  return {
-    amount,
-    remainder: match[2].trim()
-  };
-}
-function cleanupUnit(value) {
-  let unit = value.trim();
-  unit = unit.replace(/^[,.-]+/, "").trim();
-  unit = unit.replace(/[.,]+$/, "").trim();
-  unit = unit.replace(/^of\s+/i, "").trim();
-  return unit;
-}
-function extractParenthetical(text) {
-  const match = text.match(/^(.+?)\s*\(([^)]+)\)\s*$/);
-  if (!match) {
-    return { main: text, paren: null };
-  }
-  return {
-    main: match[1].trim(),
-    paren: match[2].trim()
-  };
-}
-function extractServingsFromParen(text) {
-  const match = text.match(/(\d+)/);
-  if (!match) return null;
-  const value = parseInt(match[1], 10);
-  return Number.isNaN(value) ? null : value;
-}
-function inferServings(amount, unit) {
-  if (SERVING_UNITS.includes(unit.toLowerCase())) {
-    return amount;
-  }
-  return void 0;
-}
-function wordToNumber(word) {
-  const normalized = word.toLowerCase();
-  if (NUMBER_WORDS2.hasOwnProperty(normalized)) {
-    return NUMBER_WORDS2[normalized];
-  }
-  return null;
-}
+// src/specVersion.ts
+var SOUSTACK_SPEC_VERSION = "0.2.1";
 
-export { extractRecipeFromHTML, extractSchemaOrgRecipeFromHTML, formatDuration, formatYield2 as formatYield, fromSchemaOrg, normalizeImage, normalizeIngredientInput, normalizeYield, parseDuration, parseHumanDuration, parseIngredient, parseIngredientLine, parseIngredients, parseYield2 as parseYield, scaleRecipe, scrapeRecipe, smartParseDuration, toSchemaOrg, validateRecipe };
+export { SOUSTACK_SPEC_VERSION, detectProfiles, extractSchemaOrgRecipeFromHTML, fromSchemaOrg, scaleRecipe, toSchemaOrg, validateRecipe };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map