soustack 0.2.1 → 0.3.0

package/dist/index.js

@@ -2,1125 +2,1064 @@
 
 var Ajv = require('ajv');
 var addFormats = require('ajv-formats');
-var cheerio = require('cheerio');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
 
+// 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 = {
+// src/schemas/recipe/base.schema.json
+var base_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2",
-  title: "Soustack Recipe Schema v0.2",
-  description: "A portable, scalable, interoperable recipe format.",
+  $id: "http://soustack.org/schema/recipe/base.schema.json",
+  title: "Soustack Recipe Base Schema",
+  description: "Base document shape for Soustack recipe documents. Profiles and modules build on this baseline.",
   type: "object",
-  required: ["name", "ingredients", "instructions"],
+  additionalProperties: true,
   properties: {
-    id: {
-      type: "string",
-      description: "Unique identifier (slug or UUID)"
+    "@type": {
+      const: "Recipe",
+      description: "Document marker for Soustack recipes"
     },
-    name: {
+    profile: {
       type: "string",
-      description: "The title of the recipe"
+      description: "Profile identifier applied to this recipe"
     },
-    version: {
-      type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "Semantic versioning (e.g., 1.0.0)"
-    },
-    description: {
-      type: "string"
+    modules: {
+      type: "array",
+      description: "List of module identifiers applied to this recipe",
+      items: {
+        type: "string"
+      }
     },
-    category: {
+    name: {
       type: "string",
-      examples: ["Main Course", "Dessert"]
+      description: "Human-readable recipe name"
     },
-    tags: {
+    ingredients: {
       type: "array",
-      items: { type: "string" }
+      description: "Ingredients payload; content is validated by profiles/modules"
     },
-    image: {
-      description: "Recipe-level hero image(s)",
-      anyOf: [
-        {
-          type: "string",
-          format: "uri"
+    instructions: {
+      type: "array",
+      description: "Instruction payload; content is validated by profiles/modules"
+    }
+  },
+  required: ["@type"]
+};
+
+// src/schemas/recipe/profiles/core.schema.json
+var core_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/recipe/profiles/core.schema.json",
+  title: "Soustack Recipe Core Profile",
+  description: "Core profile that builds on the minimal profile and is intended to be combined with recipe modules.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/recipe/base.schema.json" },
+    {
+      type: "object",
+      properties: {
+        profile: { const: "core" },
+        modules: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
         },
-        {
+        name: { type: "string", minLength: 1 },
+        ingredients: { type: "array", minItems: 1 },
+        instructions: { type: "array", minItems: 1 }
+      },
+      required: ["profile", "name", "ingredients", "instructions"],
+      additionalProperties: true
+    }
+  ]
+};
+
+// src/schemas/recipe/profiles/minimal.schema.json
+var minimal_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/recipe/profiles/minimal.schema.json",
+  title: "Soustack Recipe Minimal Profile",
+  description: "Minimal profile that ensures the basic Recipe structure is present while allowing modules to extend it.",
+  allOf: [
+    {
+      $ref: "http://soustack.org/schema/recipe/base.schema.json"
+    },
+    {
+      type: "object",
+      properties: {
+        profile: {
+          const: "minimal"
+        },
+        modules: {
           type: "array",
-          minItems: 1,
           items: {
             type: "string",
-            format: "uri"
-          }
+            enum: [
+              "attribution@1",
+              "taxonomy@1",
+              "media@1",
+              "nutrition@1",
+              "times@1"
+            ]
+          },
+          default: []
+        },
+        name: {
+          type: "string",
+          minLength: 1
+        },
+        ingredients: {
+          type: "array",
+          minItems: 1
+        },
+        instructions: {
+          type: "array",
+          minItems: 1
         }
-      ]
-    },
-    dateAdded: {
-      type: "string",
-      format: "date-time"
+      },
+      required: [
+        "profile",
+        "name",
+        "ingredients",
+        "instructions"
+      ],
+      additionalProperties: true
+    }
+  ]
+};
+
+// src/schemas/recipe/modules/schedule/1.schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/schedule/1.schema.json",
+  title: "Soustack Recipe Module: schedule v1",
+  description: "Schema for the schedule module. Enforces bidirectional module gating and restricts usage to the core profile.",
+  type: "object",
+  properties: {
+    profile: { type: "string" },
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    source: {
+    schedule: {
       type: "object",
       properties: {
-        author: { type: "string" },
-        url: { type: "string", format: "uri" },
-        name: { type: "string" },
-        adapted: { type: "boolean" }
+        tasks: { type: "array" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "schedule@1" }
+          }
+        }
+      },
+      then: {
+        required: ["schedule", "profile"],
+        properties: {
+          profile: { const: "core" }
+        }
       }
     },
-    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" }
-        ]
+    {
+      if: {
+        required: ["schedule"]
+      },
+      then: {
+        required: ["modules", "profile"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "schedule@1" }
+          },
+          profile: { const: "core" }
+        }
       }
-    },
-    instructions: {
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/nutrition/1.schema.json
+var schema_default2 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/nutrition/1.schema.json",
+  title: "Soustack Recipe Module: nutrition v1",
+  description: "Schema for the nutrition module. Keeps nutrition data aligned with module declarations and vice versa.",
+  type: "object",
+  properties: {
+    modules: {
       type: "array",
-      items: {
-        anyOf: [
-          { type: "string" },
-          { $ref: "#/definitions/instruction" },
-          { $ref: "#/definitions/instructionSubsection" }
-        ]
-      }
-    },
-    storage: {
-      $ref: "#/definitions/storage"
+      items: { type: "string" }
     },
-    substitutions: {
-      type: "array",
-      items: { $ref: "#/definitions/substitution" }
-    }
-  },
-  definitions: {
-    yield: {
+    nutrition: {
       type: "object",
-      required: ["amount", "unit"],
       properties: {
-        amount: { type: "number" },
-        unit: { type: "string" },
-        servings: { type: "number" },
-        description: { type: "string" }
+        calories: { type: "number" },
+        protein_g: { type: "number" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "nutrition@1" }
+          }
+        }
+      },
+      then: {
+        required: ["nutrition"]
       }
     },
-    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" }
+    {
+      if: {
+        required: ["nutrition"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "nutrition@1" }
           }
         }
-      ]
-    },
-    quantity: {
-      type: "object",
-      required: ["amount"],
-      properties: {
-        amount: { type: "number" },
-        unit: { type: ["string", "null"] }
       }
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/attribution/1.schema.json
+var schema_default3 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/attribution/1.schema.json",
+  title: "Soustack Recipe Module: attribution v1",
+  description: "Schema for the attribution module. Ensures namespace data is present when the module is enabled and vice versa.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    scaling: {
+    attribution: {
       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" }
+        url: { type: "string" },
+        author: { type: "string" },
+        datePublished: { type: "string" }
       },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
       if: {
-        properties: { type: { const: "bakers_percentage" } }
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "attribution@1" }
+          }
+        }
       },
       then: {
-        required: ["referenceId"]
+        required: ["attribution"]
       }
     },
-    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" }
+    {
+      if: {
+        required: ["attribution"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "attribution@1" }
+          }
         }
       }
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/taxonomy/1.schema.json
+var schema_default4 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/taxonomy/1.schema.json",
+  title: "Soustack Recipe Module: taxonomy v1",
+  description: "Schema for the taxonomy module. Enforces keyword and categorization data when enabled and ensures module declaration accompanies the namespace block.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    equipment: {
+    taxonomy: {
       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" }
+        keywords: { type: "array", items: { type: "string" } },
+        category: { type: "string" },
+        cuisine: { type: "string" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "taxonomy@1" }
+          }
         }
+      },
+      then: {
+        required: ["taxonomy"]
       }
     },
-    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: { type: "number" },
-            type: { type: "string", enum: ["active", "passive"] },
-            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+    {
+      if: {
+        required: ["taxonomy"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "taxonomy@1" }
           }
         }
       }
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/media/1.schema.json
+var schema_default5 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/media/1.schema.json",
+  title: "Soustack Recipe Module: media v1",
+  description: "Schema for the media module. Guards media blocks based on module activation and ensures declarations accompany payloads.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    instructionSubsection: {
+    media: {
       type: "object",
-      required: ["subsection", "items"],
       properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: {
-            anyOf: [
-              { type: "string" },
-              { $ref: "#/definitions/instruction" }
-            ]
+        images: { type: "array", items: { type: "string" } },
+        videos: { type: "array", items: { type: "string" } }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "media@1" }
           }
         }
+      },
+      then: {
+        required: ["media"]
       }
     },
-    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"] }
-                }
-              }
-            ]
+    {
+      if: {
+        required: ["media"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "media@1" }
           }
         }
       }
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/times/1.schema.json
+var schema_default6 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/times/1.schema.json",
+  title: "Soustack Recipe Module: times v1",
+  description: "Schema for the times module. Maintains alignment between module declarations and timing payloads.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    storageMethod: {
+    times: {
       type: "object",
-      required: ["duration"],
       properties: {
-        duration: { type: "string", pattern: "^P" },
-        method: { type: "string" },
-        notes: { type: "string" }
+        prepMinutes: { type: "number" },
+        cookMinutes: { type: "number" },
+        totalMinutes: { type: "number" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "times@1" }
+          }
+        }
+      },
+      then: {
+        required: ["times"]
       }
     },
-    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" }
-              }
-            }
+    {
+      if: {
+        required: ["times"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "times@1" }
           }
         }
       }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
 // src/validator.ts
-var ajv = new Ajv__default.default();
-addFormats__default.default(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" }
-    };
+var CANONICAL_BASE_SCHEMA_ID = base_schema_default.$id || "http://soustack.org/schema/recipe/base.schema.json";
+var canonicalProfileId = (profile) => {
+  if (profile === "minimal") {
+    return minimal_schema_default.$id;
   }
-  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;
+  if (profile === "core") {
+    return core_schema_default.$id;
   }
-  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);
-      }
-      const hyphenValue = NUMBER_WORDS[hyphenPart.toLowerCase()];
-      if (hyphenValue === void 0) {
-        return formatDecimal(baseValue);
-      }
-      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}`
-      };
-    }
-  }
-  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
-      };
-    }
-  }
-  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 "";
-    }
-    const maybeMeasurement = parseMeasurement(trimmed);
-    if (maybeMeasurement && !measurement) {
-      measurement = maybeMeasurement;
-      return "";
-    }
-    notes.push(trimmed);
-    return "";
-  });
-  return {
-    cleaned: cleaned.replace(/\s+/g, " ").trim(),
-    measurement,
-    notes,
-    optional
+  throw new Error(`Unknown profile: ${profile}`);
+};
+var moduleIdToSchemaRef = (moduleId) => {
+  const match = moduleId.match(/^([a-z0-9_-]+)@(\d+(?:\.\d+)*)$/i);
+  if (!match) {
+    throw new Error(`Invalid module identifier '${moduleId}'. Expected <name>@<version>.`);
+  }
+  const [, name, version] = match;
+  const moduleSchemas2 = {
+    "schedule@1": schema_default,
+    "nutrition@1": schema_default2,
+    "attribution@1": schema_default3,
+    "taxonomy@1": schema_default4,
+    "media@1": schema_default5,
+    "times@1": schema_default6
   };
-}
-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]}`);
+  const schema = moduleSchemas2[moduleId];
+  if (schema && schema.$id) {
+    return schema.$id;
+  }
+  return `https://soustack.org/schemas/recipe/modules/${name}/${version}.schema.json`;
+};
+var profileSchemas = {
+  minimal: minimal_schema_default,
+  core: core_schema_default
+};
+var moduleSchemas = {
+  "schedule@1": schema_default,
+  "nutrition@1": schema_default2,
+  "attribution@1": schema_default3,
+  "taxonomy@1": schema_default4,
+  "media@1": schema_default5,
+  "times@1": schema_default6
+};
+var validationContexts = /* @__PURE__ */ new Map();
+function createContext(collectAllErrors) {
+  const ajv = new Ajv__default.default({ strict: false, allErrors: collectAllErrors });
+  addFormats__default.default(ajv);
+  const addSchemaWithAlias = (schema, alias) => {
+    if (!schema) return;
+    const schemaId = schema.$id || alias;
+    if (schemaId) {
+      ajv.addSchema(schema, schemaId);
     } else {
-      notes.push(rangeText);
-    }
-    working = afterRange;
-  } else {
-    const numberMatch = working.match(NUMBER_REGEX);
-    if (numberMatch) {
-      amount = parseNumber(numberMatch[1]);
-      originalAmount = amount;
-      working = working.slice(numberMatch[0].length).trim();
-    }
-  }
-  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();
-      }
+      ajv.addSchema(schema);
     }
-  }
-  return {
-    amount,
-    unit,
-    descriptor,
-    remainder: working.trim(),
-    notes,
-    originalAmount
   };
+  addSchemaWithAlias(base_schema_default, CANONICAL_BASE_SCHEMA_ID);
+  Object.entries(profileSchemas).forEach(([name, schema]) => {
+    addSchemaWithAlias(schema, canonicalProfileId(name));
+  });
+  Object.entries(moduleSchemas).forEach(([moduleId, schema]) => {
+    addSchemaWithAlias(schema, moduleIdToSchemaRef(moduleId));
+  });
+  return { ajv, validators: /* @__PURE__ */ new Map() };
 }
-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 };
+  return void 0;
 }
-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();
+function resolveSchemaRef(inputSchema, requestedSchema) {
+  if (typeof requestedSchema === "string") return requestedSchema;
+  if (typeof inputSchema !== "string") return void 0;
+  return detectProfileFromSchema(inputSchema) ? inputSchema : void 0;
+}
+function inferModulesFromPayload(recipe) {
+  const inferred = [];
+  const payloadToModule = {
+    attribution: "attribution@1",
+    taxonomy: "taxonomy@1",
+    media: "media@1",
+    times: "times@1",
+    nutrition: "nutrition@1",
+    schedule: "schedule@1"
+  };
+  for (const [field, moduleId] of Object.entries(payloadToModule)) {
+    if (recipe && typeof recipe === "object" && field in recipe && recipe[field] != null) {
+      const payload = recipe[field];
+      if (typeof payload === "object" && !Array.isArray(payload)) {
+        if (Object.keys(payload).length > 0) {
+          inferred.push(moduleId);
+        }
+      } else if (Array.isArray(payload) && payload.length > 0) {
+        inferred.push(moduleId);
+      } else if (payload !== null && payload !== void 0) {
+        inferred.push(moduleId);
+      }
     }
   }
-  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
+  return inferred;
+}
+function getCombinedValidator(profile, modules, recipe, context) {
+  const inferredModules = inferModulesFromPayload(recipe);
+  const allModules = /* @__PURE__ */ new Set([...modules, ...inferredModules]);
+  const sortedModules = Array.from(allModules).sort();
+  const cacheKey = `${profile}::${sortedModules.join(",")}`;
+  const cached = context.validators.get(cacheKey);
+  if (cached) return cached;
+  if (!profileSchemas[profile]) {
+    throw new Error(`Unknown Soustack profile: ${profile}`);
+  }
+  const schema = {
+    $id: `urn:soustack:recipe:${cacheKey}`,
+    allOf: [
+      { $ref: CANONICAL_BASE_SCHEMA_ID },
+      { $ref: canonicalProfileId(profile) },
+      ...sortedModules.map((moduleId) => ({ $ref: moduleIdToSchemaRef(moduleId) }))
+    ]
   };
-}
-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;
-    }
-    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 validateFn = context.ajv.compile(schema);
+  context.validators.set(cacheKey, validateFn);
+  return validateFn;
+}
+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;
     }
-  }
-  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)
-    )
+var _a, _b;
+var allowedTopLevelProps = /* @__PURE__ */ new Set([
+  ...Object.keys((_b = (_a = base_schema_default) == null ? void 0 : _a.properties) != null ? _b : {}),
+  "$schema",
+  // Module fields (validated by module schemas)
+  "attribution",
+  "taxonomy",
+  "media",
+  "times",
+  "nutrition",
+  "schedule",
+  // Common recipe fields (allowed by base schema's additionalProperties: true)
+  "description",
+  "image",
+  "category",
+  "tags",
+  "source",
+  "dateAdded",
+  "dateModified",
+  "yield",
+  "time",
+  "id",
+  "title",
+  "recipeVersion",
+  "version",
+  // deprecated but allowed
+  "equipment",
+  "storage",
+  "substitutions"
+]);
+function detectUnknownTopLevelKeys(recipe) {
+  if (!recipe || typeof recipe !== "object") return [];
+  const disallowedKeys = Object.keys(recipe).filter(
+    (key) => !allowedTopLevelProps.has(key) && !key.startsWith("x-")
   );
-  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 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, "/") || "/";
   }
-  return trimmed;
-}
-
-// src/converters/ingredient.ts
-function parseIngredientLine2(line) {
-  const parsed = parseIngredient(line);
-  const ingredient = {
-    item: parsed.item,
-    scaling: parsed.scaling ?? { type: "linear" }
+  return {
+    path,
+    keyword: error.keyword,
+    message: error.message || "Validation error"
   };
-  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;
+function runAjvValidation(data, profile, modules, context) {
+  try {
+    const validateFn = getCombinedValidator(profile, modules, data, context);
+    const isValid = validateFn(data);
+    return !isValid && validateFn.errors ? validateFn.errors.map(formatAjvError) : [];
+  } catch (error) {
+    return [
+      {
+        path: "/",
+        message: error instanceof Error ? error.message : "Validation failed to initialize"
+      }
+    ];
+  }
+}
+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 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);
+    }
+  });
+  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);
+  };
+  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 = resolveSchemaRef(input == null ? void 0 : input.$schema, options.schema);
+  const profileFromDocument = typeof (input == null ? void 0 : input.profile) === "string" ? input.profile : void 0;
+  const profile = (_d = (_c = (_b2 = options.profile) != null ? _b2 : profileFromDocument) != null ? _c : detectProfileFromSchema(schemaRef)) != null ? _d : "core";
+  const modulesFromDocument = Array.isArray(input == null ? void 0 : input.modules) ? input.modules.filter((value) => typeof value === "string") : [];
+  const modules = modulesFromDocument.length > 0 ? [...modulesFromDocument].sort() : [];
+  const { normalized, warnings } = normalizeRecipe(input);
+  if (!profileFromDocument) {
+    normalized.profile = profile;
+  } else {
+    normalized.profile = profileFromDocument;
   }
-  if (parsedQuantity.amount === null || Number.isNaN(parsedQuantity.amount)) {
-    return void 0;
+  if (!("modules" in normalized) || normalized.modules === void 0 || normalized.modules === null) {
+    normalized.modules = [];
+  } else if (modulesFromDocument.length > 0) {
+    normalized.modules = modules;
   }
+  const unknownKeyErrors = detectUnknownTopLevelKeys(normalized);
+  const validationErrors = runAjvValidation(normalized, profile, modules, context);
+  const graphErrors = modules.includes("schedule@1") && 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: "core", collectAllErrors: false });
+  if (!result.valid) return [];
+  const normalizedRecipe = (_a2 = result.normalized) != null ? _a2 : recipe;
+  const profiles = [];
+  const context = getContext(false);
+  Object.keys(profileSchemas).forEach((profile) => {
+    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) {
@@ -1162,96 +1101,16 @@ function parseYield(value) {
   return void 0;
 }
 function formatYield(yieldValue) {
+  var _a2;
   if (!yieldValue) return void 0;
   if (!yieldValue.amount && !yieldValue.unit) {
     return void 0;
   }
-  const amount = yieldValue.amount ?? "";
+  const amount = (_a2 = yieldValue.amount) != null ? _a2 : "";
   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;
-  }
-  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/utils/image.ts
 function normalizeImage(image) {
   if (!image) {
@@ -1288,6 +1147,7 @@ function extractUrl(value) {
 
 // src/fromSchemaOrg.ts
 function fromSchemaOrg(input) {
+  var _a2;
   const recipeNode = extractRecipeNode(input);
   if (!recipeNode) {
     return null;
@@ -1299,21 +1159,39 @@ function fromSchemaOrg(input) {
   const tags = collectTags(recipeNode.recipeCuisine, recipeNode.keywords);
   const category = extractFirst(recipeNode.recipeCategory);
   const source = convertSource(recipeNode);
-  const nutrition = recipeNode.nutrition && typeof recipeNode.nutrition === "object" ? recipeNode.nutrition : void 0;
+  const dateModified = recipeNode.dateModified || void 0;
+  const nutrition = convertNutrition(recipeNode.nutrition);
+  const attribution = convertAttribution(recipeNode);
+  const taxonomy = convertTaxonomy(tags, category, extractFirst(recipeNode.recipeCuisine));
+  const media = convertMedia(recipeNode.image, recipeNode.video);
+  const times = convertTimes(time);
+  const modules = [];
+  if (attribution) modules.push("attribution@1");
+  if (taxonomy) modules.push("taxonomy@1");
+  if (media) modules.push("media@1");
+  if (nutrition) modules.push("nutrition@1");
+  if (times) modules.push("times@1");
   return {
+    "@type": "Recipe",
+    profile: "minimal",
+    modules: modules.sort(),
     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,
     source,
     dateAdded: recipeNode.datePublished || void 0,
-    dateModified: recipeNode.dateModified || void 0,
     yield: recipeYield,
     time,
     ingredients,
     instructions,
-    nutrition
+    ...dateModified ? { dateModified } : {},
+    ...nutrition ? { nutrition } : {},
+    ...attribution ? { attribution } : {},
+    ...taxonomy ? { taxonomy } : {},
+    ...media ? { media } : {},
+    ...times ? { times } : {}
   };
 }
 function extractRecipeNode(input) {
@@ -1348,8 +1226,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"
   );
@@ -1360,9 +1236,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 = [];
@@ -1379,7 +1256,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
         });
       }
@@ -1428,10 +1305,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";
@@ -1440,9 +1340,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;
@@ -1475,9 +1376,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;
@@ -1505,16 +1407,186 @@ function extractEntityName(value) {
   }
   return void 0;
 }
+function convertAttribution(recipe) {
+  var _a2, _b2;
+  const attribution = {};
+  const url = (_a2 = recipe.url || recipe.mainEntityOfPage) == null ? void 0 : _a2.trim();
+  const author = extractEntityName(recipe.author);
+  const datePublished = (_b2 = recipe.datePublished) == null ? void 0 : _b2.trim();
+  if (url) attribution.url = url;
+  if (author) attribution.author = author;
+  if (datePublished) attribution.datePublished = datePublished;
+  return Object.keys(attribution).length ? attribution : void 0;
+}
+function convertTaxonomy(keywords, category, cuisine) {
+  const taxonomy = {};
+  if (keywords.length) taxonomy.keywords = keywords;
+  if (category) taxonomy.category = category;
+  if (cuisine) taxonomy.cuisine = cuisine;
+  return Object.keys(taxonomy).length ? taxonomy : void 0;
+}
+function normalizeMediaList(value) {
+  if (!value) return [];
+  if (typeof value === "string") return [value.trim()].filter(Boolean);
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? item.trim() : extractMediaUrl(item)).filter((entry) => Boolean(entry == null ? void 0 : entry.length));
+  }
+  const url = extractMediaUrl(value);
+  return url ? [url] : [];
+}
+function extractMediaUrl(value) {
+  if (value && typeof value === "object" && "url" in value && typeof value.url === "string") {
+    const trimmed = value.url.trim();
+    return trimmed || void 0;
+  }
+  return void 0;
+}
+function convertMedia(image, video) {
+  const normalizedImage = normalizeImage(image);
+  const images = normalizedImage ? Array.isArray(normalizedImage) ? normalizedImage : [normalizedImage] : [];
+  const videos = normalizeMediaList(video);
+  const media = {};
+  if (images.length) media.images = images;
+  if (videos.length) media.videos = videos;
+  return Object.keys(media).length ? media : void 0;
+}
+function convertTimes(time) {
+  if (!time) return void 0;
+  const times = {};
+  if (typeof time.prep === "number") times.prepMinutes = time.prep;
+  if (typeof time.active === "number") times.cookMinutes = time.active;
+  if (typeof time.total === "number") times.totalMinutes = time.total;
+  return Object.keys(times).length ? times : void 0;
+}
+function convertNutrition(nutrition) {
+  if (!nutrition || typeof nutrition !== "object") {
+    return void 0;
+  }
+  const result = {};
+  let hasData = false;
+  if ("calories" in nutrition) {
+    const calories = nutrition.calories;
+    if (typeof calories === "number") {
+      result.calories = calories;
+      hasData = true;
+    } else if (typeof calories === "string") {
+      const parsed = parseFloat(calories.replace(/[^\d.-]/g, ""));
+      if (!isNaN(parsed)) {
+        result.calories = parsed;
+        hasData = true;
+      }
+    }
+  }
+  if ("proteinContent" in nutrition || "protein_g" in nutrition) {
+    const protein = nutrition.proteinContent || nutrition.protein_g;
+    if (typeof protein === "number") {
+      result.protein_g = protein;
+      hasData = true;
+    } else if (typeof protein === "string") {
+      const parsed = parseFloat(protein.replace(/[^\d.-]/g, ""));
+      if (!isNaN(parsed)) {
+        result.protein_g = parsed;
+        hasData = true;
+      }
+    }
+  }
+  return hasData ? result : void 0;
+}
+
+// src/schemas/registry/modules.json
+var modules_default = {
+  modules: [
+    {
+      id: "attribution",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/attribution",
+      schema: "https://soustack.org/schemas/recipe/modules/attribution/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "taxonomy",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/taxonomy",
+      schema: "https://soustack.org/schemas/recipe/modules/taxonomy/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "high",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "media",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/media",
+      schema: "https://soustack.org/schemas/recipe/modules/media/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "nutrition",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/nutrition",
+      schema: "https://soustack.org/schemas/recipe/modules/nutrition/1.schema.json",
+      schemaOrgMappable: false,
+      schemaOrgConfidence: "low",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "times",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/times",
+      schema: "https://soustack.org/schemas/recipe/modules/times/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "schedule",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/schedule",
+      schema: "https://soustack.org/schemas/recipe/modules/schedule/1.schema.json",
+      schemaOrgMappable: false,
+      schemaOrgConfidence: "low",
+      minProfile: "core",
+      allowedOnMinimal: false
+    }
+  ]
+};
 
 // 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
   });
@@ -1522,6 +1594,7 @@ function convertBasicMetadata(recipe) {
 function convertIngredients2(ingredients = []) {
   const result = [];
   ingredients.forEach((ingredient) => {
+    var _a2;
     if (!ingredient) {
       return;
     }
@@ -1551,7 +1624,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);
     }
@@ -1566,10 +1639,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;
     }
@@ -1585,18 +1659,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;
   }
@@ -1604,10 +1673,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) {
@@ -1635,6 +1717,22 @@ function convertTime2(time) {
   }
   return result;
 }
+function convertTimesModule(times) {
+  if (!times) {
+    return {};
+  }
+  const result = {};
+  if (times.prepMinutes !== void 0) {
+    result.prepTime = formatDuration(times.prepMinutes);
+  }
+  if (times.cookMinutes !== void 0) {
+    result.cookTime = formatDuration(times.cookMinutes);
+  }
+  if (times.totalMinutes !== void 0) {
+    result.totalTime = formatDuration(times.totalMinutes);
+  }
+  return result;
+}
 function convertYield(yld) {
   if (!yld) {
     return void 0;
@@ -1673,145 +1771,63 @@ function convertCategoryTags(category, tags) {
   }
   return result;
 }
-function convertNutrition(nutrition) {
+function convertNutrition2(nutrition) {
   if (!nutrition) {
     return void 0;
   }
-  return {
-    ...nutrition,
+  const result = {
     "@type": "NutritionInformation"
   };
+  if (nutrition.calories !== void 0) {
+    if (typeof nutrition.calories === "number") {
+      result.calories = `${nutrition.calories} calories`;
+    } else {
+      result.calories = nutrition.calories;
+    }
+  }
+  Object.keys(nutrition).forEach((key) => {
+    if (key !== "calories" && key !== "@type") {
+      result[key] = nutrition[key];
+    }
+  });
+  return result;
 }
 function cleanOutput(obj) {
   return Object.fromEntries(
     Object.entries(obj).filter(([, value]) => value !== void 0)
   );
 }
+function getSchemaOrgMappableModules(modules = []) {
+  const mappableModules = modules_default.modules.filter((m) => m.schemaOrgMappable).map((m) => `${m.id}@${m.latest}`);
+  return modules.filter((moduleId) => mappableModules.includes(moduleId));
+}
 function toSchemaOrg(recipe) {
   const base = convertBasicMetadata(recipe);
   const ingredients = convertIngredients2(recipe.ingredients);
   const instructions = convertInstructions2(recipe.instructions);
-  const nutrition = convertNutrition(recipe.nutrition);
+  const recipeModules = Array.isArray(recipe.modules) ? recipe.modules : [];
+  const mappableModules = getSchemaOrgMappableModules(recipeModules);
+  const hasMappableNutrition = mappableModules.includes("nutrition@1");
+  const nutrition = hasMappableNutrition ? convertNutrition2(recipe.nutrition) : void 0;
+  const hasMappableTimes = mappableModules.includes("times@1");
+  const timeData = hasMappableTimes ? recipe.times ? convertTimesModule(recipe.times) : convertTime2(recipe.time) : {};
+  const hasMappableAttribution = mappableModules.includes("attribution@1");
+  const attributionData = hasMappableAttribution ? convertAuthor(recipe.source) : {};
+  const hasMappableTaxonomy = mappableModules.includes("taxonomy@1");
+  const taxonomyData = hasMappableTaxonomy ? convertCategoryTags(recipe.category, recipe.tags) : {};
   return cleanOutput({
     ...base,
-    recipeIngredient: ingredients.length ? ingredients : void 0,
-    recipeInstructions: instructions.length ? instructions : void 0,
-    recipeYield: convertYield(recipe.yield),
-    ...convertTime2(recipe.time),
-    ...convertAuthor(recipe.source),
-    ...convertCategoryTags(recipe.category, recipe.tags),
-    nutrition
-  });
-}
-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");
+    recipeIngredient: ingredients.length ? ingredients : void 0,
+    recipeInstructions: instructions.length ? instructions : void 0,
+    recipeYield: convertYield(recipe.yield),
+    ...timeData,
+    ...attributionData,
+    ...taxonomyData,
+    nutrition
+  });
+}
+function isStructuredTime(time) {
+  return typeof time.prep !== "undefined" || typeof time.active !== "undefined" || typeof time.passive !== "undefined" || typeof time.total !== "undefined";
 }
 
 // src/scraper/extractors/utils.ts
@@ -1850,97 +1866,8 @@ function normalizeText(value) {
   return trimmed || void 0;
 }
 
-// src/scraper/extractors/jsonld.ts
-function extractJsonLd(html) {
-  const $ = cheerio.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 $ = cheerio.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) {
@@ -1953,6 +1880,7 @@ function extractRecipeBrowser(html) {
   return { recipe: null, source: null };
 }
 function extractJsonLdBrowser(html) {
+  var _a2;
   if (typeof globalThis.DOMParser === "undefined") {
     return null;
   }
@@ -1965,9 +1893,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") {
@@ -1982,8 +1910,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;
     }
@@ -2000,7 +1928,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) {
@@ -2011,15 +1940,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") {
@@ -2031,381 +1960,542 @@ function collectCandidates2(payload, bucket) {
   }
   const graph = payload["@graph"];
   if (Array.isArray(graph)) {
-    graph.forEach((entry) => collectCandidates2(entry, bucket));
+    graph.forEach((entry) => collectCandidates(entry, bucket));
   }
 }
 
-// src/scraper/extractors/index.ts
-function isBrowser() {
-  try {
-    return typeof globalThis.DOMParser !== "undefined";
-  } catch {
-    return false;
-  }
+// src/scraper/browser.ts
+function extractSchemaOrgRecipeFromHTML(html) {
+  const { recipe } = extractRecipeBrowser(html);
+  return recipe;
 }
-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 {
-    }
+
+// src/specVersion.ts
+var SOUSTACK_SPEC_VERSION = "0.3.0";
+
+// src/conversion/units.ts
+var MASS_UNITS = {
+  g: {
+    dimension: "mass",
+    toMetricBase: 1,
+    metricBaseUnit: "g",
+    isMetric: true
+  },
+  kg: {
+    dimension: "mass",
+    toMetricBase: 1e3,
+    metricBaseUnit: "g",
+    isMetric: true
+  },
+  oz: {
+    dimension: "mass",
+    toMetricBase: 28.349523125,
+    metricBaseUnit: "g",
+    isMetric: false
+  },
+  lb: {
+    dimension: "mass",
+    toMetricBase: 453.59237,
+    metricBaseUnit: "g",
+    isMetric: false
   }
-  if (jsonLdRecipe) {
-    return { recipe: jsonLdRecipe, source: "jsonld" };
+};
+var VOLUME_UNITS = {
+  ml: {
+    dimension: "volume",
+    toMetricBase: 1,
+    metricBaseUnit: "ml",
+    isMetric: true
+  },
+  l: {
+    dimension: "volume",
+    toMetricBase: 1e3,
+    metricBaseUnit: "ml",
+    isMetric: true
+  },
+  tsp: {
+    dimension: "volume",
+    toMetricBase: 4.92892159375,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  tbsp: {
+    dimension: "volume",
+    toMetricBase: 14.78676478125,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  fl_oz: {
+    dimension: "volume",
+    toMetricBase: 29.5735295625,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  cup: {
+    dimension: "volume",
+    toMetricBase: 236.5882365,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  pint: {
+    dimension: "volume",
+    toMetricBase: 473.176473,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  quart: {
+    dimension: "volume",
+    toMetricBase: 946.352946,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  gallon: {
+    dimension: "volume",
+    toMetricBase: 3785.411784,
+    metricBaseUnit: "ml",
+    isMetric: false
   }
-  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 {
-    }
+};
+var COUNT_UNITS = {
+  clove: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  sprig: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  leaf: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  pinch: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  bottle: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  count: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
   }
-  if (microdataRecipe) {
-    return { recipe: microdataRecipe, source: "microdata" };
+};
+var UNIT_DEFINITIONS = {
+  ...MASS_UNITS,
+  ...VOLUME_UNITS,
+  ...COUNT_UNITS
+};
+function normalizeUnitToken(unit) {
+  var _a2;
+  if (!unit) {
+    return null;
   }
-  return { recipe: null, source: null };
+  const token = unit.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  const canonical = (_a2 = UNIT_SYNONYMS[token]) != null ? _a2 : token;
+  return canonical in UNIT_DEFINITIONS ? canonical : null;
+}
+var UNIT_SYNONYMS = {
+  teaspoons: "tsp",
+  teaspoon: "tsp",
+  tsps: "tsp",
+  tbsp: "tbsp",
+  tbsps: "tbsp",
+  tablespoon: "tbsp",
+  tablespoons: "tbsp",
+  cup: "cup",
+  cups: "cup",
+  pint: "pint",
+  pints: "pint",
+  quart: "quart",
+  quarts: "quart",
+  gallon: "gallon",
+  gallons: "gallon",
+  ml: "ml",
+  milliliter: "ml",
+  milliliters: "ml",
+  millilitre: "ml",
+  millilitres: "ml",
+  l: "l",
+  liter: "l",
+  liters: "l",
+  litre: "l",
+  litres: "l",
+  fl_oz: "fl_oz",
+  "fl.oz": "fl_oz",
+  "fl.oz.": "fl_oz",
+  "fl_oz.": "fl_oz",
+  "fl oz": "fl_oz",
+  "fl oz.": "fl_oz",
+  fluid_ounce: "fl_oz",
+  fluid_ounces: "fl_oz",
+  oz: "oz",
+  ounce: "oz",
+  ounces: "oz",
+  lb: "lb",
+  lbs: "lb",
+  pound: "lb",
+  pounds: "lb",
+  g: "g",
+  gram: "g",
+  grams: "g",
+  kg: "kg",
+  kilogram: "kg",
+  kilograms: "kg",
+  clove: "clove",
+  cloves: "clove",
+  sprig: "sprig",
+  sprigs: "sprig",
+  leaf: "leaf",
+  leaves: "leaf",
+  pinch: "pinch",
+  pinches: "pinch",
+  bottle: "bottle",
+  bottles: "bottle",
+  count: "count",
+  counts: "count"
+};
+function convertToMetricBase(quantity, unit) {
+  const definition = UNIT_DEFINITIONS[unit];
+  const quantityInMetricBase = quantity * definition.toMetricBase;
+  return {
+    quantity: quantityInMetricBase,
+    baseUnit: definition.metricBaseUnit,
+    definition
+  };
 }
 
-// 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 {
-    }
+// src/conversion/convertLineItem.ts
+var UnknownUnitError = class extends Error {
+  constructor(unit) {
+    super(`Unknown unit "${unit}".`);
+    this.unit = unit;
+    this.name = "UnknownUnitError";
   }
-  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 {
-    }
+};
+var UnsupportedConversionError = class extends Error {
+  constructor(unit, mode) {
+    super(`Cannot convert unit "${unit}" in ${mode} mode.`);
+    this.unit = unit;
+    this.mode = mode;
+    this.name = "UnsupportedConversionError";
   }
-  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 {
+};
+var MissingEquivalencyError = class extends Error {
+  constructor(ingredient, unit) {
+    super(
+      `No volume to mass equivalency for "${ingredient}" (${unit}).`
+    );
+    this.ingredient = ingredient;
+    this.unit = unit;
+    this.name = "MissingEquivalencyError";
+  }
+};
+var VOLUME_TO_MASS_EQUIV_G_PER_UNIT = {
+  flour: {
+    cup: 120
+  }
+};
+var DEFAULT_ROUND_MODE = "sane";
+function convertLineItemToMetric(item, mode, opts) {
+  var _a2, _b2, _c, _d;
+  const roundMode = (_a2 = opts == null ? void 0 : opts.round) != null ? _a2 : DEFAULT_ROUND_MODE;
+  const normalizedUnit = normalizeUnitToken(item.unit);
+  if (!normalizedUnit) {
+    if (!item.unit || item.unit.trim() === "") {
+      return item;
     }
+    throw new UnknownUnitError(item.unit);
   }
-  if (!recipe) {
-    throw new Error("No Schema.org recipe data found in page");
+  const definition = UNIT_DEFINITIONS[normalizedUnit];
+  if (definition.dimension === "count") {
+    return item;
   }
-  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 (mode === "volume") {
+    if (definition.dimension !== "volume") {
+      throw new UnsupportedConversionError((_b2 = item.unit) != null ? _b2 : "", mode);
     }
+    const { quantity, unit } = finalizeMetricVolume(
+      convertToMetricBase(item.quantity, normalizedUnit).quantity,
+      roundMode
+    );
+    return {
+      ...item,
+      quantity,
+      unit
+    };
   }
-  if (!soustackRecipe) {
-    throw new Error("Schema.org data did not include a valid recipe");
+  if (definition.dimension === "mass") {
+    const { quantity, unit } = finalizeMetricMass(
+      convertToMetricBase(item.quantity, normalizedUnit).quantity,
+      roundMode
+    );
+    return {
+      ...item,
+      quantity,
+      unit
+    };
   }
-  return soustackRecipe;
-}
-function extractRecipeFromHTML(html) {
-  const { recipe } = extractRecipe(html);
-  if (!recipe) {
-    throw new Error("No Schema.org recipe data found in HTML");
+  if (definition.dimension !== "volume") {
+    throw new UnsupportedConversionError((_c = item.unit) != null ? _c : "", mode);
   }
-  const soustackRecipe = fromSchemaOrg(recipe);
-  if (!soustackRecipe) {
-    throw new Error("Schema.org data did not include a valid recipe");
+  const gramsPerUnit = lookupEquivalency(
+    item.ingredient,
+    normalizedUnit
+  );
+  if (!gramsPerUnit) {
+    throw new MissingEquivalencyError(item.ingredient, (_d = item.unit) != null ? _d : "");
   }
-  return soustackRecipe;
-}
-function extractSchemaOrgRecipeFromHTML(html) {
-  const { recipe } = extractRecipe(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, " ");
+  const grams = item.quantity * gramsPerUnit;
+  const massResult = finalizeMetricMass(grams, roundMode);
+  return {
+    ...item,
+    quantity: massResult.quantity,
+    unit: massResult.unit,
+    notes: `Converted using ${gramsPerUnit}g per ${normalizedUnit} for ${item.ingredient}.`
+  };
 }
-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;
+function finalizeMetricVolume(milliliters, roundMode) {
+  if (roundMode === "none") {
+    return milliliters >= 1e3 ? { quantity: milliliters / 1e3, unit: "l" } : { quantity: milliliters, unit: "ml" };
   }
-  if (core.servings === void 0) {
-    const inferred = inferServings(core.amount, core.unit);
-    if (inferred !== void 0) {
-      core.servings = inferred;
-    }
+  const roundedMl = roundMilliliters(milliliters);
+  if (roundedMl >= 1e3) {
+    const liters = roundedMl / 1e3;
+    return {
+      quantity: roundLargeMetric(liters),
+      unit: "l"
+    };
   }
-  return core;
+  return { quantity: roundedMl, unit: "ml" };
 }
-function formatYield2(value) {
-  if (value.description) {
-    return value.description;
+function finalizeMetricMass(grams, roundMode) {
+  if (roundMode === "none") {
+    return grams >= 1e3 ? { quantity: grams / 1e3, unit: "kg" } : { quantity: grams, unit: "g" };
   }
-  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)`;
+  const roundedGrams = roundGrams(grams);
+  if (roundedGrams >= 1e3) {
+    const kilograms = roundedGrams / 1e3;
+    return {
+      quantity: roundLargeMetric(kilograms),
+      unit: "kg"
+    };
   }
-  return result;
+  return { quantity: roundedGrams, unit: "g" };
 }
-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;
+function roundGrams(value) {
+  if (value < 1e3) {
+    return Math.round(value);
   }
-  return null;
+  return Math.round(value / 5) * 5;
 }
-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;
+function roundMilliliters(value) {
+  if (value < 1e3) {
+    return Math.round(value);
   }
-  return parseRangePattern(remainder, original) ?? parseNumberUnitPattern(remainder, original) ?? parsePlainNumberPattern(remainder);
+  return Math.round(value / 10) * 10;
 }
-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 roundLargeMetric(value) {
+  return Math.round(value * 100) / 100;
 }
-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
+function lookupEquivalency(ingredient, unit) {
+  var _a2;
+  const key = ingredient.trim().toLowerCase();
+  return (_a2 = VOLUME_TO_MASS_EQUIV_G_PER_UNIT[key]) == null ? void 0 : _a2[unit];
+}
+
+// src/mise-en-place/index.ts
+function miseEnPlace(ingredients) {
+  const list = Array.isArray(ingredients) ? ingredients : [];
+  const prepGroups = /* @__PURE__ */ new Map();
+  const stateGroups = /* @__PURE__ */ new Map();
+  let measureTask;
+  let otherTask;
+  const ungrouped = [];
+  for (const ingredient of list) {
+    if (!ingredient || typeof ingredient !== "object") continue;
+    const label = deriveIngredientLabel(ingredient);
+    const quantity = normalizeQuantity(ingredient.quantity);
+    const baseNotes = toDisplayString(ingredient.notes);
+    const prepNotes = toDisplayString(ingredient.prep);
+    const isOptional = typeof ingredient.optional === "boolean" ? ingredient.optional : void 0;
+    const buildItem = (extraNotes) => {
+      const item = {
+        ingredient: label
+      };
+      if (quantity) {
+        item.quantity = { ...quantity };
+      }
+      if (typeof isOptional === "boolean") {
+        item.optional = isOptional;
+      }
+      const notes = combineNotes(extraNotes, baseNotes);
+      if (notes) {
+        item.notes = notes;
+      }
+      return item;
     };
-    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;
+    let addedToTask = false;
+    let hasPrepGrouping = false;
+    const prepActionKeys = extractNormalizedList(ingredient.prepActions);
+    if (prepActionKeys.length > 0) {
+      hasPrepGrouping = true;
+      for (const actionKey of prepActionKeys) {
+        const task = ensureGroup(prepGroups, actionKey, () => ({
+          category: "prep",
+          action: actionKey,
+          items: []
+        }));
+        task.items.push(buildItem());
+        addedToTask = true;
       }
-    }
-  }
-  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;
+    } else {
+      const singleActionKey = normalizeKey(ingredient.prepAction);
+      if (singleActionKey) {
+        hasPrepGrouping = true;
+        const task = ensureGroup(prepGroups, singleActionKey, () => ({
+          category: "prep",
+          action: singleActionKey,
+          items: []
+        }));
+        task.items.push(buildItem());
+        addedToTask = true;
+      } else if (prepNotes) {
+        otherTask = otherTask != null ? otherTask : { category: "other", items: [] };
+        otherTask.items.push(buildItem(prepNotes));
+        addedToTask = true;
       }
     }
+    const formKey = normalizeKey(ingredient.form);
+    const hasStateGrouping = Boolean(formKey);
+    if (formKey) {
+      const task = ensureGroup(stateGroups, formKey, () => ({
+        category: "state",
+        form: formKey,
+        items: []
+      }));
+      task.items.push(buildItem());
+      addedToTask = true;
+    }
+    const shouldMeasure = Boolean(quantity) && !hasPrepGrouping && !hasStateGrouping;
+    if (shouldMeasure) {
+      measureTask = measureTask != null ? measureTask : { category: "measure", items: [] };
+      measureTask.items.push(buildItem());
+      addedToTask = true;
+    }
+    if (!addedToTask) {
+      ungrouped.push(ingredient);
+    }
   }
-  return null;
+  const tasks = [
+    ...Array.from(prepGroups.values()).sort((a, b) => localeCompare(a.action, b.action)),
+    ...Array.from(stateGroups.values()).sort((a, b) => localeCompare(a.form, b.form))
+  ];
+  if (measureTask) {
+    tasks.push(measureTask);
+  }
+  if (otherTask) {
+    tasks.push(otherTask);
+  }
+  return { tasks, ungrouped };
 }
-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 deriveIngredientLabel(ingredient) {
+  var _a2, _b2, _c;
+  return (_c = (_b2 = (_a2 = toDisplayString(ingredient.name)) != null ? _a2 : toDisplayString(ingredient.item)) != null ? _b2 : toDisplayString(ingredient.id)) != null ? _c : "ingredient";
 }
-function stripApproximation(value) {
-  const match = value.match(APPROX_PREFIX);
-  if (!match) {
-    return { value: value.trim(), approximate: false };
+function extractNormalizedList(values) {
+  if (!Array.isArray(values)) {
+    return [];
   }
-  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);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const key = normalizeKey(value);
+    if (key && !seen.has(key)) {
+      seen.add(key);
+      result.push(key);
+    }
   }
-  if (multiplier === null) return null;
-  const amount = multiplier * 12;
-  return {
-    amount,
-    remainder: match[2].trim()
-  };
+  return result;
 }
-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 normalizeKey(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim().toLowerCase();
+  return trimmed || null;
 }
-function extractParenthetical(text) {
-  const match = text.match(/^(.+?)\s*\(([^)]+)\)\s*$/);
-  if (!match) {
-    return { main: text, paren: null };
+function toDisplayString(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  return {
-    main: match[1].trim(),
-    paren: match[2].trim()
-  };
+  const trimmed = value.trim();
+  return trimmed || void 0;
 }
-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 combineNotes(...notes) {
+  const cleaned = notes.map((note) => toDisplayString(note != null ? note : void 0)).filter(Boolean);
+  if (cleaned.length === 0) {
+    return void 0;
+  }
+  return cleaned.join(" | ");
 }
-function inferServings(amount, unit) {
-  if (SERVING_UNITS.includes(unit.toLowerCase())) {
-    return amount;
+function normalizeQuantity(quantity) {
+  if (!quantity || typeof quantity !== "object") {
+    return void 0;
   }
-  return void 0;
+  const amount = quantity.amount;
+  if (typeof amount !== "number" || Number.isNaN(amount)) {
+    return void 0;
+  }
+  const normalized = { amount };
+  if ("unit" in quantity) {
+    const unit = quantity.unit;
+    if (typeof unit === "string") {
+      const trimmed = unit.trim();
+      if (trimmed) {
+        normalized.unit = trimmed;
+      }
+    } else if (unit === null) {
+      normalized.unit = null;
+    }
+  }
+  return normalized;
 }
-function wordToNumber(word) {
-  const normalized = word.toLowerCase();
-  if (NUMBER_WORDS2.hasOwnProperty(normalized)) {
-    return NUMBER_WORDS2[normalized];
+function ensureGroup(map, key, factory) {
+  let task = map.get(key);
+  if (!task) {
+    task = factory();
+    map.set(key, task);
   }
-  return null;
+  return task;
+}
+function localeCompare(left, right) {
+  return (left != null ? left : "").localeCompare(right != null ? right : "");
 }
 
-exports.extractRecipeFromHTML = extractRecipeFromHTML;
+exports.MissingEquivalencyError = MissingEquivalencyError;
+exports.SOUSTACK_SPEC_VERSION = SOUSTACK_SPEC_VERSION;
+exports.UnknownUnitError = UnknownUnitError;
+exports.UnsupportedConversionError = UnsupportedConversionError;
+exports.convertLineItemToMetric = convertLineItemToMetric;
+exports.detectProfiles = detectProfiles;
 exports.extractSchemaOrgRecipeFromHTML = extractSchemaOrgRecipeFromHTML;
-exports.formatDuration = formatDuration;
-exports.formatYield = formatYield2;
 exports.fromSchemaOrg = fromSchemaOrg;
-exports.normalizeImage = normalizeImage;
-exports.normalizeIngredientInput = normalizeIngredientInput;
-exports.normalizeYield = normalizeYield;
-exports.parseDuration = parseDuration;
-exports.parseHumanDuration = parseHumanDuration;
-exports.parseIngredient = parseIngredient;
-exports.parseIngredientLine = parseIngredientLine;
-exports.parseIngredients = parseIngredients;
-exports.parseYield = parseYield2;
+exports.miseEnPlace = miseEnPlace;
 exports.scaleRecipe = scaleRecipe;
-exports.scrapeRecipe = scrapeRecipe;
-exports.smartParseDuration = smartParseDuration;
 exports.toSchemaOrg = toSchemaOrg;
 exports.validateRecipe = validateRecipe;
 //# sourceMappingURL=index.js.map