soustack 0.2.1 → 0.2.3

package/dist/cli/index.js

@@ -3,9 +3,10 @@
 
 var fs = require('fs');
 var path = require('path');
+var glob = require('glob');
+var cheerio = require('cheerio');
 var Ajv = require('ajv');
 var addFormats = require('ajv-formats');
-var cheerio = require('cheerio');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -32,1146 +33,275 @@ var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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) => (ing.scaling?.type || "linear") !== "bakers_percentage").forEach((ing) => {
+    const key = getIngredientKey(ing);
+    scaledAmounts.set(key, calculateIndependentIngredient(ing, multiplier));
+  });
+  orderedIngredients.filter((ing) => ing.scaling?.type === "bakers_percentage").forEach((ing) => {
+    const key = getIngredientKey(ing);
+    const scaling = ing.scaling;
+    if (!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 = ing.quantity?.amount || 0;
+    const referenceBase = baseAmounts.get(scaling.referenceId);
+    const factor = scaling.factor ?? (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) {
+  if (options.multiplier && options.multiplier > 0) {
+    return options.multiplier;
+  }
+  if (options.targetYield?.amount) {
+    const base = recipe.yield?.amount || 1;
+    return options.targetYield.amount / base;
+  }
+  return 1;
+}
+function applyYieldScaling(recipe, options, multiplier) {
+  const baseAmount = recipe.yield?.amount ?? 1;
+  const targetAmount = options.targetYield?.amount ?? baseAmount * multiplier;
+  const unit = options.targetYield?.unit ?? recipe.yield?.unit;
+  if (!recipe.yield && !options.targetYield) return;
+  recipe.yield = {
+    amount: targetAmount,
+    unit: 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) {
+function calculateIndependentIngredient(ing, multiplier) {
   const baseAmount = ing.quantity?.amount || 0;
   const type = ing.scaling?.type || "linear";
-  let newAmount = baseAmount;
   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 = ing.scaling?.roundTo ?? 1;
+      const rounded = Math.round(scaled / step) * step;
+      return Math.round(rounded);
+    }
+    case "proportional": {
+      const factor = ing.scaling?.factor ?? 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));
+    if (typeof item === "string") return;
+    if ("subsection" in item) {
+      collectBaseIngredientAmounts(item.items, map);
     } else {
-      result.push(item);
+      map.set(getIngredientKey(item), item.quantity?.amount ?? 0);
     }
   });
-  return result;
+  return map;
+}
+function scaleInstructionItems(items, multiplier) {
+  items.forEach((item) => {
+    if (typeof item === "string") return;
+    if ("subsection" in item) {
+      scaleInstructionItems(item.items, multiplier);
+      return;
+    }
+    const timing = item.timing;
+    if (!timing) return;
+    const baseDuration = toDurationMinutes(timing.duration);
+    const scalingType = timing.scaling || "fixed";
+    let newDuration = baseDuration;
+    if (scalingType === "linear") {
+      newDuration = baseDuration * multiplier;
+    } else if (scalingType === "sqrt") {
+      newDuration = baseDuration * Math.sqrt(multiplier);
+    }
+    timing.duration = Math.ceil(newDuration);
+  });
+}
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function toDurationMinutes(duration) {
+  if (typeof duration === "number" && Number.isFinite(duration)) {
+    return duration;
+  }
+  if (typeof duration === "string" && duration.trim().startsWith("P")) {
+    const parsed = parseDuration(duration.trim());
+    if (parsed !== null) {
+      return parsed;
+    }
+  }
+  return 0;
 }
 
-// src/schema.json
-var schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2",
-  title: "Soustack Recipe Schema v0.2",
-  description: "A portable, scalable, interoperable recipe format.",
-  type: "object",
-  required: ["name", "ingredients", "instructions"],
-  properties: {
-    id: {
-      type: "string",
-      description: "Unique identifier (slug or UUID)"
-    },
-    name: {
-      type: "string",
-      description: "The title of the recipe"
-    },
-    version: {
-      type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "Semantic versioning (e.g., 1.0.0)"
-    },
-    description: {
-      type: "string"
-    },
-    category: {
-      type: "string",
-      examples: ["Main Course", "Dessert"]
-    },
-    tags: {
-      type: "array",
-      items: { type: "string" }
-    },
-    image: {
-      description: "Recipe-level hero image(s)",
-      anyOf: [
-        {
-          type: "string",
-          format: "uri"
-        },
-        {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "string",
-            format: "uri"
-          }
-        }
-      ]
-    },
-    dateAdded: {
-      type: "string",
-      format: "date-time"
-    },
-    source: {
-      type: "object",
-      properties: {
-        author: { type: "string" },
-        url: { type: "string", format: "uri" },
-        name: { type: "string" },
-        adapted: { type: "boolean" }
-      }
-    },
-    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" }
-        ]
-      }
-    },
-    instructions: {
-      type: "array",
-      items: {
-        anyOf: [
-          { type: "string" },
-          { $ref: "#/definitions/instruction" },
-          { $ref: "#/definitions/instructionSubsection" }
-        ]
-      }
-    },
-    storage: {
-      $ref: "#/definitions/storage"
-    },
-    substitutions: {
-      type: "array",
-      items: { $ref: "#/definitions/substitution" }
-    }
-  },
-  definitions: {
-    yield: {
-      type: "object",
-      required: ["amount", "unit"],
-      properties: {
-        amount: { type: "number" },
-        unit: { type: "string" },
-        servings: { type: "number" },
-        description: { type: "string" }
-      }
-    },
-    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" }
-          }
-        }
-      ]
-    },
-    quantity: {
-      type: "object",
-      required: ["amount"],
-      properties: {
-        amount: { type: "number" },
-        unit: { type: ["string", "null"] }
-      }
-    },
-    scaling: {
-      type: "object",
-      required: ["type"],
-      properties: {
-        type: {
-          type: "string",
-          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
-        },
-        factor: { type: "number" },
-        referenceId: { type: "string" },
-        roundTo: { type: "number" },
-        min: { type: "number" },
-        max: { type: "number" }
-      },
-      if: {
-        properties: { type: { const: "bakers_percentage" } }
-      },
-      then: {
-        required: ["referenceId"]
-      }
-    },
-    ingredient: {
-      type: "object",
-      required: ["item"],
-      properties: {
-        id: { type: "string" },
-        item: { type: "string" },
-        quantity: { $ref: "#/definitions/quantity" },
-        name: { type: "string" },
-        aisle: { type: "string" },
-        prep: { type: "string" },
-        prepAction: { type: "string" },
-        prepTime: { type: "number" },
-        destination: { type: "string" },
-        scaling: { $ref: "#/definitions/scaling" },
-        critical: { type: "boolean" },
-        optional: { type: "boolean" },
-        notes: { type: "string" }
-      }
-    },
-    ingredientSubsection: {
-      type: "object",
-      required: ["subsection", "items"],
-      properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: { $ref: "#/definitions/ingredient" }
-        }
-      }
-    },
-    equipment: {
-      type: "object",
-      required: ["name"],
-      properties: {
-        id: { type: "string" },
-        name: { type: "string" },
-        required: { type: "boolean" },
-        label: { type: "string" },
-        capacity: { $ref: "#/definitions/quantity" },
-        scalingLimit: { type: "number" },
-        alternatives: {
-          type: "array",
-          items: { type: "string" }
-        }
-      }
-    },
-    instruction: {
-      type: "object",
-      required: ["text"],
-      properties: {
-        id: { type: "string" },
-        text: { type: "string" },
-        image: {
-          type: "string",
-          format: "uri",
-          description: "Optional image that illustrates this instruction"
-        },
-        destination: { type: "string" },
-        dependsOn: {
-          type: "array",
-          items: { type: "string" }
-        },
-        inputs: {
-          type: "array",
-          items: { type: "string" }
-        },
-        timing: {
-          type: "object",
-          required: ["duration", "type"],
-          properties: {
-            duration: { type: "number" },
-            type: { type: "string", enum: ["active", "passive"] },
-            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
-          }
-        }
-      }
-    },
-    instructionSubsection: {
-      type: "object",
-      required: ["subsection", "items"],
-      properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: {
-            anyOf: [
-              { type: "string" },
-              { $ref: "#/definitions/instruction" }
-            ]
-          }
-        }
-      }
-    },
-    storage: {
-      type: "object",
-      properties: {
-        roomTemp: { $ref: "#/definitions/storageMethod" },
-        refrigerated: { $ref: "#/definitions/storageMethod" },
-        frozen: {
-          allOf: [
-            { $ref: "#/definitions/storageMethod" },
-            {
-              type: "object",
-              properties: { thawing: { type: "string" } }
-            }
-          ]
-        },
-        reheating: { type: "string" },
-        makeAhead: {
-          type: "array",
-          items: {
-            allOf: [
-              { $ref: "#/definitions/storageMethod" },
-              {
-                type: "object",
-                required: ["component", "storage"],
-                properties: {
-                  component: { type: "string" },
-                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
-                }
-              }
-            ]
-          }
-        }
-      }
-    },
-    storageMethod: {
-      type: "object",
-      required: ["duration"],
-      properties: {
-        duration: { type: "string", pattern: "^P" },
-        method: { type: "string" },
-        notes: { type: "string" }
-      }
-    },
-    substitution: {
-      type: "object",
-      required: ["ingredient"],
-      properties: {
-        ingredient: { type: "string" },
-        critical: { type: "boolean" },
-        notes: { type: "string" },
-        alternatives: {
-          type: "array",
-          items: {
-            type: "object",
-            required: ["name", "ratio"],
-            properties: {
-              name: { type: "string" },
-              ratio: { type: "string" },
-              notes: { type: "string" },
-              impact: { type: "string" },
-              dietary: {
-                type: "array",
-                items: { type: "string" }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-// 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" }
-    };
-  }
-  let working = normalized;
-  const notes = [];
-  let optional = false;
-  if (/\boptional\b/i.test(working)) {
-    optional = true;
-    working = working.replace(/\(?\s*optional\s*\)?/gi, "").trim();
-    working = working.replace(/\(\s*\)/g, " ").trim();
-  }
-  const flavorExtraction = extractFlavorNotes(working);
-  working = flavorExtraction.cleaned;
-  notes.push(...flavorExtraction.notes);
-  const parenthetical = extractParentheticals(working);
-  working = parenthetical.cleaned;
-  notes.push(...parenthetical.notes);
-  optional = optional || parenthetical.optional;
-  const purposeExtraction = extractPurposeNotes(working);
-  working = purposeExtraction.cleaned;
-  notes.push(...purposeExtraction.notes);
-  const juiceExtraction = extractJuicePhrase(working);
-  if (juiceExtraction) {
-    working = juiceExtraction.cleaned;
-    notes.push(juiceExtraction.note);
-  }
-  const vagueQuantity = extractVagueQuantity(working);
-  let quantityResult;
-  if (vagueQuantity) {
-    notes.push(vagueQuantity.note);
-    quantityResult = {
-      amount: null,
-      unit: null,
-      descriptor: void 0,
-      remainder: vagueQuantity.remainder,
-      notes: [],
-      originalAmount: null
-    };
-  } else {
-    quantityResult = extractQuantity(working);
-  }
-  working = quantityResult.remainder;
-  const { quantity, usedParenthetical } = mergeQuantities(quantityResult, parenthetical.measurement);
-  if (usedParenthetical && quantityResult.originalAmount !== null && quantityResult.originalAmount > 1 && quantityResult.descriptor && DESCRIPTOR_NOTE_SET.has(quantityResult.descriptor.toLowerCase())) {
-    notes.push(formatCountNote(quantityResult.originalAmount, quantityResult.descriptor));
-  }
-  notes.push(...quantityResult.notes);
-  working = working.replace(/^[,.\s-]+/, "").trim();
-  working = working.replace(/^of\s+/i, "").trim();
-  if (quantityResult.descriptor && /^cans?$/i.test(quantityResult.descriptor) && working && !/^canned\b/i.test(working)) {
-    working = `canned ${working}`.trim();
-  }
-  const nameExtraction = extractNameAndPrep(working);
-  notes.push(...nameExtraction.notes);
-  const name = nameExtraction.name || void 0;
-  const scaling = inferScaling(
-    name,
-    quantity.unit,
-    quantity.amount,
-    notes,
-    quantityResult.descriptor
-  );
-  const mergedNotes = formatNotes(notes);
-  const parsed = {
-    item: original,
-    quantity,
-    ...name ? { name } : {},
-    ...nameExtraction.prep ? { prep: nameExtraction.prep } : {},
-    ...optional ? { optional: true } : {},
-    scaling
-  };
-  if (mergedNotes) {
-    parsed.notes = mergedNotes;
-  }
-  return parsed;
-}
-function 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}`
-      };
+// src/converters/yield.ts
+function parseYield(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return {
+      amount: value,
+      unit: "servings"
+    };
+  }
+  if (Array.isArray(value)) {
+    return parseYield(value[0]);
+  }
+  if (typeof value === "object") {
+    const maybeYield = value;
+    if (typeof maybeYield.amount === "number") {
+      return {
+        amount: maybeYield.amount,
+        unit: typeof maybeYield.unit === "string" ? maybeYield.unit : "servings",
+        description: typeof maybeYield.description === "string" ? maybeYield.description : void 0
+      };
     }
   }
-  return void 0;
-}
-function extractVagueQuantity(value) {
-  for (const pattern of VAGUE_QUANTITY_PATTERNS) {
-    const match = value.match(pattern.regex);
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const match = trimmed.match(/(\d+(?:\.\d+)?)/);
     if (match) {
-      let remainder = value.slice(match[0].length).trim();
-      remainder = remainder.replace(/^of\s+/i, "").trim();
+      const amount = parseFloat(match[1]);
+      const unit = trimmed.slice(match.index + match[1].length).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
-  };
-}
-function parseMeasurement(value) {
-  const stripped = value.replace(/^(about|around|approximately|approx\.?|roughly)\s+/i, "").trim();
-  const match = stripped.match(
-    /^((?:\d+\s+)?\d+\/\d+|\d+\/\d+|\d+(?:\.\d+)?)(?:\s*)([a-zA-Z]+)?$/
-  );
-  if (!match) return void 0;
-  const amount = parseNumber(match[1]);
-  if (amount === null) return void 0;
-  const unit = match[2] ? normalizeUnit(match[2]) ?? match[2].toLowerCase() : null;
-  return { amount, unit };
-}
-function extractQuantity(value) {
-  let working = value.trim();
-  const notes = [];
-  let amount = null;
-  let originalAmount = null;
-  let unit = null;
-  let descriptor;
-  while (QUALIFIER_REGEX.test(working)) {
-    working = working.replace(QUALIFIER_REGEX, "").trim();
-  }
-  const rangeMatch = working.match(RANGE_REGEX);
-  if (rangeMatch) {
-    amount = parseNumber(rangeMatch[1]);
-    originalAmount = amount;
-    const rangeText = rangeMatch[0].trim();
-    const afterRange = working.slice(rangeMatch[0].length).trim();
-    const descriptorMatch = afterRange.match(/^([a-zA-Z]+)/);
-    if (descriptorMatch && COUNT_DESCRIPTORS.has(descriptorMatch[1].toLowerCase())) {
-      notes.push(`${rangeText} ${descriptorMatch[1]}`);
-    } else {
-      notes.push(rangeText);
-    }
-    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();
-      }
-    }
-  }
-  return {
-    amount,
-    unit,
-    descriptor,
-    remainder: working.trim(),
-    notes,
-    originalAmount
-  };
-}
-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);
-  }
-  const parsed = Number(trimmed);
-  return Number.isNaN(parsed) ? null : parsed;
-}
-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];
-  }
-  if (raw === "T") return "tbsp";
-  if (raw === "t") return "tsp";
-  if (raw === "C") return "cup";
-  return null;
-}
-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
-    };
-  }
-  return { quantity, usedParenthetical: false };
-}
-function extractNameAndPrep(value) {
-  let working = value.trim();
-  const notes = [];
-  let prep;
-  const lastComma = working.lastIndexOf(",");
-  if (lastComma >= 0) {
-    const trailing = working.slice(lastComma + 1).trim();
-    if (isPrepPhrase(trailing)) {
-      prep = trailing;
-      working = working.slice(0, lastComma).trim();
-    }
-  }
-  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
-  };
-}
-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;
-    }
-  }
-  return result;
-}
-function isPrepPhrase(value) {
-  const normalized = value.toLowerCase();
-  return PREP_PHRASES.includes(normalized);
-}
-function inferScaling(name, unit, amount, notes, descriptor) {
-  const lowerName = name?.toLowerCase() ?? "";
-  const normalizedNotes = notes.map((note) => note.toLowerCase());
-  const descriptorLower = descriptor?.toLowerCase();
-  if (lowerName.includes("egg") || descriptorLower === "clove" || descriptorLower === "cloves" || normalizedNotes.some((note) => note.includes("clove"))) {
-    return { type: "discrete", roundTo: 1 };
-  }
-  if (descriptorLower === "stick" || descriptorLower === "sticks") {
-    return { type: "discrete", roundTo: 1 };
-  }
-  if (normalizedNotes.some((note) => PURPOSE_KEYWORDS.some((keyword) => note.includes(keyword)))) {
-    return { type: "fixed" };
-  }
-  const isSpice = SPICE_KEYWORDS.some((keyword) => lowerName.includes(keyword));
-  const smallUnit = unit ? ["tsp", "tbsp", "dash", "pinch"].includes(unit) : false;
-  if (normalizedNotes.some((note) => note.includes("to taste")) || isSpice && (smallUnit || amount !== null && amount <= 1)) {
-    return { type: "proportional", factor: 0.7 };
-  }
-  return { type: "linear" };
-}
-function formatNotes(notes) {
-  const cleaned = Array.from(
-    new Set(
-      notes.map((note) => note.trim()).filter(Boolean)
-    )
-  );
-  return cleaned.length ? cleaned.join("; ") : void 0;
-}
-function formatCountNote(amount, descriptor) {
-  const lower = descriptor.toLowerCase();
-  const singular = lower.endsWith("s") ? lower.slice(0, -1) : lower;
-  const word = amount === 1 ? singular : singular.endsWith("ch") || singular.endsWith("sh") || singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") ? `${singular}es` : singular.endsWith("y") && !/[aeiou]y$/.test(singular) ? `${singular.slice(0, -1)}ies` : `${singular}s`;
-  return `${formatDecimal(amount)} ${word}`;
-}
-function singularize(value) {
-  const trimmed = value.trim();
-  if (trimmed.endsWith("ies")) {
-    return `${trimmed.slice(0, -3)}y`;
-  }
-  if (/(ches|shes|sses|xes|zes)$/i.test(trimmed)) {
-    return trimmed.slice(0, -2);
-  }
-  if (trimmed.endsWith("s")) {
-    return trimmed.slice(0, -1);
-  }
-  return trimmed;
-}
-
-// src/converters/ingredient.ts
-function parseIngredientLine(line) {
-  const parsed = parseIngredient(line);
-  const ingredient = {
-    item: parsed.item,
-    scaling: parsed.scaling ?? { type: "linear" }
-  };
-  if (parsed.name) {
-    ingredient.name = parsed.name;
-  }
-  if (parsed.prep) {
-    ingredient.prep = parsed.prep;
-  }
-  if (parsed.optional) {
-    ingredient.optional = true;
-  }
-  if (parsed.notes) {
-    ingredient.notes = parsed.notes;
-  }
-  const quantity = buildQuantity(parsed.quantity);
-  if (quantity) {
-    ingredient.quantity = quantity;
-  }
-  return ingredient;
-}
-function buildQuantity(parsedQuantity) {
-  if (!parsedQuantity) {
-    return void 0;
-  }
-  if (parsedQuantity.amount === null || Number.isNaN(parsedQuantity.amount)) {
-    return void 0;
-  }
-  return {
-    amount: parsedQuantity.amount,
-    unit: parsedQuantity.unit ?? null
-  };
-}
-
-// src/converters/yield.ts
-function parseYield(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value === "number") {
-    return {
-      amount: value,
-      unit: "servings"
-    };
-  }
-  if (Array.isArray(value)) {
-    return parseYield(value[0]);
-  }
-  if (typeof value === "object") {
-    const maybeYield = value;
-    if (typeof maybeYield.amount === "number") {
-      return {
-        amount: maybeYield.amount,
-        unit: typeof maybeYield.unit === "string" ? maybeYield.unit : "servings",
-        description: typeof maybeYield.description === "string" ? maybeYield.description : void 0
-      };
-    }
-  }
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    const match = trimmed.match(/(\d+(?:\.\d+)?)/);
-    if (match) {
-      const amount = parseFloat(match[1]);
-      const unit = trimmed.slice(match.index + match[1].length).trim();
-      return {
-        amount,
-        unit: unit || "servings",
-        description: trimmed
+        amount,
+        unit: unit || "servings",
+        description: trimmed
       };
     }
   }
@@ -1187,87 +317,6 @@ function formatYield(yieldValue) {
   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) {
@@ -1364,8 +413,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"
   );
@@ -1376,7 +423,7 @@ 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) => parseIngredientLine(line));
+  return normalized.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
 }
 function convertInstructions(value) {
   if (!value) return [];
@@ -1444,10 +491,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;
   }
-  return text;
+  const parsed = smartParseDuration(duration);
+  return { duration: parsed ?? duration, type: "active" };
+}
+function extractInstructionId(step) {
+  const raw = step["@id"] || step.id || step.url;
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed || void 0;
 }
 function isHowToStep(value) {
   return Boolean(value) && typeof value === "object" && value["@type"] === "HowToStep";
@@ -1582,10 +652,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;
     }
@@ -1604,13 +675,7 @@ function createHowToStep(entry) {
   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();
   if (!trimmed) {
@@ -1620,10 +685,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) {
@@ -2049,199 +1127,1454 @@ function collectCandidates2(payload, bucket) {
   if (Array.isArray(graph)) {
     graph.forEach((entry) => collectCandidates2(entry, bucket));
   }
-}
+}
+
+// src/scraper/extractors/index.ts
+function isBrowser() {
+  try {
+    return typeof globalThis.DOMParser !== "undefined";
+  } catch {
+    return false;
+  }
+}
+function extractRecipe(html) {
+  if (isBrowser()) {
+    return extractRecipeBrowser(html);
+  }
+  const jsonLdRecipe = extractJsonLd(html);
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
+    try {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+      if (globalFetch) {
+        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:6", message: "JSON-LD extraction result", data: { hasJsonLd: !!jsonLdRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  if (jsonLdRecipe) {
+    return { recipe: jsonLdRecipe, source: "jsonld" };
+  }
+  const microdataRecipe = extractMicrodata(html);
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
+    try {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+      if (globalFetch) {
+        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:12", message: "Microdata extraction result", data: { hasMicrodata: !!microdataRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "D" }) }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  if (microdataRecipe) {
+    return { recipe: microdataRecipe, source: "microdata" };
+  }
+  return { recipe: null, source: null };
+}
+
+// src/scraper/index.ts
+async function scrapeRecipe(url, options = {}) {
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
+    try {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+      if (globalFetch) {
+        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:7", message: "scrapeRecipe entry", data: { url, hasOptions: !!options }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,B,C,D,E" }) }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  const html = await fetchPage(url, options);
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
+    try {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+      if (globalFetch) {
+        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:9", message: "HTML fetched", data: { htmlLength: html?.length, htmlPreview: html?.substring(0, 200) }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  const { recipe } = extractRecipe(html);
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
+    try {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+      if (globalFetch) {
+        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:11", message: "extractRecipe result", data: { hasRecipe: !!recipe, recipeType: recipe?.["@type"], recipeName: recipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C,D" }) }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  if (!recipe) {
+    throw new Error("No Schema.org recipe data found in page");
+  }
+  const soustackRecipe = fromSchemaOrg(recipe);
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
+    try {
+      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+      if (globalFetch) {
+        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:17", message: "fromSchemaOrg result", data: { hasSoustackRecipe: !!soustackRecipe, soustackRecipeName: soustackRecipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  if (!soustackRecipe) {
+    throw new Error("Schema.org data did not include a valid recipe");
+  }
+  return soustackRecipe;
+}
+
+// src/schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1",
+  title: "Soustack Recipe Schema v0.2.1",
+  description: "A portable, scalable, interoperable recipe format.",
+  type: "object",
+  required: ["name", "ingredients", "instructions"],
+  additionalProperties: false,
+  patternProperties: {
+    "^x-": {}
+  },
+  properties: {
+    $schema: {
+      type: "string",
+      format: "uri",
+      description: "Optional schema hint for tooling compatibility"
+    },
+    id: {
+      type: "string",
+      description: "Unique identifier (slug or UUID)"
+    },
+    name: {
+      type: "string",
+      description: "The title of the recipe"
+    },
+    title: {
+      type: "string",
+      description: "Optional display title; alias for name"
+    },
+    version: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "DEPRECATED: use recipeVersion for authoring revisions"
+    },
+    recipeVersion: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
+    },
+    description: {
+      type: "string"
+    },
+    category: {
+      type: "string",
+      examples: ["Main Course", "Dessert"]
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" }
+    },
+    image: {
+      description: "Recipe-level hero image(s)",
+      anyOf: [
+        {
+          type: "string",
+          format: "uri"
+        },
+        {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            format: "uri"
+          }
+        }
+      ]
+    },
+    dateAdded: {
+      type: "string",
+      format: "date-time"
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      description: "Free-form vendor metadata"
+    },
+    source: {
+      type: "object",
+      properties: {
+        author: { type: "string" },
+        url: { type: "string", format: "uri" },
+        name: { type: "string" },
+        adapted: { type: "boolean" }
+      }
+    },
+    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" }
+        ]
+      }
+    },
+    instructions: {
+      type: "array",
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/instruction" },
+          { $ref: "#/definitions/instructionSubsection" }
+        ]
+      }
+    },
+    storage: {
+      $ref: "#/definitions/storage"
+    },
+    substitutions: {
+      type: "array",
+      items: { $ref: "#/definitions/substitution" }
+    }
+  },
+  definitions: {
+    yield: {
+      type: "object",
+      required: ["amount", "unit"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: "string" },
+        servings: { type: "number" },
+        description: { type: "string" }
+      }
+    },
+    time: {
+      type: "object",
+      properties: {
+        prep: { type: "number" },
+        active: { type: "number" },
+        passive: { type: "number" },
+        total: { type: "number" },
+        prepTime: { type: "string", format: "duration" },
+        cookTime: { type: "string", format: "duration" }
+      },
+      minProperties: 1
+    },
+    quantity: {
+      type: "object",
+      required: ["amount"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: ["string", "null"] }
+      }
+    },
+    scaling: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
+        },
+        factor: { type: "number" },
+        referenceId: { type: "string" },
+        roundTo: { type: "number" },
+        min: { type: "number" },
+        max: { type: "number" }
+      },
+      if: {
+        properties: { type: { const: "bakers_percentage" } }
+      },
+      then: {
+        required: ["referenceId"]
+      }
+    },
+    ingredient: {
+      type: "object",
+      required: ["item"],
+      properties: {
+        id: { type: "string" },
+        item: { type: "string" },
+        quantity: { $ref: "#/definitions/quantity" },
+        name: { type: "string" },
+        aisle: { type: "string" },
+        prep: { type: "string" },
+        prepAction: { type: "string" },
+        prepTime: { type: "number" },
+        destination: { type: "string" },
+        scaling: { $ref: "#/definitions/scaling" },
+        critical: { type: "boolean" },
+        optional: { type: "boolean" },
+        notes: { type: "string" }
+      }
+    },
+    ingredientSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: { $ref: "#/definitions/ingredient" }
+        }
+      }
+    },
+    equipment: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        required: { type: "boolean" },
+        label: { type: "string" },
+        capacity: { $ref: "#/definitions/quantity" },
+        scalingLimit: { type: "number" },
+        alternatives: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    },
+    instruction: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        id: { type: "string" },
+        text: { type: "string" },
+        image: {
+          type: "string",
+          format: "uri",
+          description: "Optional image that illustrates this instruction"
+        },
+        destination: { type: "string" },
+        dependsOn: {
+          type: "array",
+          items: { type: "string" }
+        },
+        inputs: {
+          type: "array",
+          items: { type: "string" }
+        },
+        timing: {
+          type: "object",
+          required: ["duration", "type"],
+          properties: {
+            duration: {
+              anyOf: [
+                { type: "number" },
+                { type: "string", pattern: "^P" }
+              ],
+              description: "Minutes as a number or ISO8601 duration string"
+            },
+            type: { type: "string", enum: ["active", "passive"] },
+            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+          }
+        }
+      }
+    },
+    instructionSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: {
+            anyOf: [
+              { type: "string" },
+              { $ref: "#/definitions/instruction" }
+            ]
+          }
+        }
+      }
+    },
+    storage: {
+      type: "object",
+      properties: {
+        roomTemp: { $ref: "#/definitions/storageMethod" },
+        refrigerated: { $ref: "#/definitions/storageMethod" },
+        frozen: {
+          allOf: [
+            { $ref: "#/definitions/storageMethod" },
+            {
+              type: "object",
+              properties: { thawing: { type: "string" } }
+            }
+          ]
+        },
+        reheating: { type: "string" },
+        makeAhead: {
+          type: "array",
+          items: {
+            allOf: [
+              { $ref: "#/definitions/storageMethod" },
+              {
+                type: "object",
+                required: ["component", "storage"],
+                properties: {
+                  component: { type: "string" },
+                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    storageMethod: {
+      type: "object",
+      required: ["duration"],
+      properties: {
+        duration: { type: "string", pattern: "^P" },
+        method: { type: "string" },
+        notes: { type: "string" }
+      }
+    },
+    substitution: {
+      type: "object",
+      required: ["ingredient"],
+      properties: {
+        ingredient: { type: "string" },
+        critical: { type: "boolean" },
+        notes: { type: "string" },
+        alternatives: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "ratio"],
+            properties: {
+              name: { type: "string" },
+              ratio: { type: "string" },
+              notes: { type: "string" },
+              impact: { type: "string" },
+              dietary: {
+                type: "array",
+                items: { type: "string" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/soustack.schema.json
+var soustack_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1",
+  title: "Soustack Recipe Schema v0.2.1",
+  description: "A portable, scalable, interoperable recipe format.",
+  type: "object",
+  required: ["name", "ingredients", "instructions"],
+  additionalProperties: false,
+  patternProperties: {
+    "^x-": {}
+  },
+  properties: {
+    $schema: {
+      type: "string",
+      format: "uri",
+      description: "Optional schema hint for tooling compatibility"
+    },
+    id: {
+      type: "string",
+      description: "Unique identifier (slug or UUID)"
+    },
+    name: {
+      type: "string",
+      description: "The title of the recipe"
+    },
+    title: {
+      type: "string",
+      description: "Optional display title; alias for name"
+    },
+    version: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "DEPRECATED: use recipeVersion for authoring revisions"
+    },
+    recipeVersion: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
+    },
+    description: {
+      type: "string"
+    },
+    category: {
+      type: "string",
+      examples: ["Main Course", "Dessert"]
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" }
+    },
+    image: {
+      description: "Recipe-level hero image(s)",
+      anyOf: [
+        {
+          type: "string",
+          format: "uri"
+        },
+        {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            format: "uri"
+          }
+        }
+      ]
+    },
+    dateAdded: {
+      type: "string",
+      format: "date-time"
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      description: "Free-form vendor metadata"
+    },
+    source: {
+      type: "object",
+      properties: {
+        author: { type: "string" },
+        url: { type: "string", format: "uri" },
+        name: { type: "string" },
+        adapted: { type: "boolean" }
+      }
+    },
+    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" }
+        ]
+      }
+    },
+    instructions: {
+      type: "array",
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/instruction" },
+          { $ref: "#/definitions/instructionSubsection" }
+        ]
+      }
+    },
+    storage: {
+      $ref: "#/definitions/storage"
+    },
+    substitutions: {
+      type: "array",
+      items: { $ref: "#/definitions/substitution" }
+    }
+  },
+  definitions: {
+    yield: {
+      type: "object",
+      required: ["amount", "unit"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: "string" },
+        servings: { type: "number" },
+        description: { type: "string" }
+      }
+    },
+    time: {
+      type: "object",
+      properties: {
+        prep: { type: "number" },
+        active: { type: "number" },
+        passive: { type: "number" },
+        total: { type: "number" },
+        prepTime: { type: "string", format: "duration" },
+        cookTime: { type: "string", format: "duration" }
+      },
+      minProperties: 1
+    },
+    quantity: {
+      type: "object",
+      required: ["amount"],
+      properties: {
+        amount: { type: "number" },
+        unit: { type: ["string", "null"] }
+      }
+    },
+    scaling: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
+        },
+        factor: { type: "number" },
+        referenceId: { type: "string" },
+        roundTo: { type: "number" },
+        min: { type: "number" },
+        max: { type: "number" }
+      },
+      if: {
+        properties: { type: { const: "bakers_percentage" } }
+      },
+      then: {
+        required: ["referenceId"]
+      }
+    },
+    ingredient: {
+      type: "object",
+      required: ["item"],
+      properties: {
+        id: { type: "string" },
+        item: { type: "string" },
+        quantity: { $ref: "#/definitions/quantity" },
+        name: { type: "string" },
+        aisle: { type: "string" },
+        prep: { type: "string" },
+        prepAction: { type: "string" },
+        prepTime: { type: "number" },
+        destination: { type: "string" },
+        scaling: { $ref: "#/definitions/scaling" },
+        critical: { type: "boolean" },
+        optional: { type: "boolean" },
+        notes: { type: "string" }
+      }
+    },
+    ingredientSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: { $ref: "#/definitions/ingredient" }
+        }
+      }
+    },
+    equipment: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        required: { type: "boolean" },
+        label: { type: "string" },
+        capacity: { $ref: "#/definitions/quantity" },
+        scalingLimit: { type: "number" },
+        alternatives: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    },
+    instruction: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        id: { type: "string" },
+        text: { type: "string" },
+        image: {
+          type: "string",
+          format: "uri",
+          description: "Optional image that illustrates this instruction"
+        },
+        destination: { type: "string" },
+        dependsOn: {
+          type: "array",
+          items: { type: "string" }
+        },
+        inputs: {
+          type: "array",
+          items: { type: "string" }
+        },
+        timing: {
+          type: "object",
+          required: ["duration", "type"],
+          properties: {
+            duration: {
+              anyOf: [
+                { type: "number" },
+                { type: "string", pattern: "^P" }
+              ],
+              description: "Minutes as a number or ISO8601 duration string"
+            },
+            type: { type: "string", enum: ["active", "passive"] },
+            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+          }
+        }
+      }
+    },
+    instructionSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: {
+            anyOf: [
+              { type: "string" },
+              { $ref: "#/definitions/instruction" }
+            ]
+          }
+        }
+      }
+    },
+    storage: {
+      type: "object",
+      properties: {
+        roomTemp: { $ref: "#/definitions/storageMethod" },
+        refrigerated: { $ref: "#/definitions/storageMethod" },
+        frozen: {
+          allOf: [
+            { $ref: "#/definitions/storageMethod" },
+            {
+              type: "object",
+              properties: { thawing: { type: "string" } }
+            }
+          ]
+        },
+        reheating: { type: "string" },
+        makeAhead: {
+          type: "array",
+          items: {
+            allOf: [
+              { $ref: "#/definitions/storageMethod" },
+              {
+                type: "object",
+                required: ["component", "storage"],
+                properties: {
+                  component: { type: "string" },
+                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    storageMethod: {
+      type: "object",
+      required: ["duration"],
+      properties: {
+        duration: { type: "string", pattern: "^P" },
+        method: { type: "string" },
+        notes: { type: "string" }
+      }
+    },
+    substitution: {
+      type: "object",
+      required: ["ingredient"],
+      properties: {
+        ingredient: { type: "string" },
+        critical: { type: "boolean" },
+        notes: { type: "string" },
+        alternatives: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "ratio"],
+            properties: {
+              name: { type: "string" },
+              ratio: { type: "string" },
+              notes: { type: "string" },
+              impact: { type: "string" },
+              dietary: {
+                type: "array",
+                items: { type: "string" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
 
-// src/scraper/extractors/index.ts
-function isBrowser() {
-  try {
-    return typeof globalThis.DOMParser !== "undefined";
-  } catch {
-    return false;
-  }
-}
-function extractRecipe(html) {
-  if (isBrowser()) {
-    return extractRecipeBrowser(html);
-  }
-  const jsonLdRecipe = extractJsonLd(html);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:6", message: "JSON-LD extraction result", data: { hasJsonLd: !!jsonLdRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
-        });
+// src/profiles/base.schema.json
+var base_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/base",
+  title: "Soustack Base Profile Schema",
+  description: "Wrapper schema that exposes the unmodified Soustack base schema.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" }
+  ]
+};
+
+// src/profiles/cookable.schema.json
+var cookable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/cookable",
+  title: "Soustack Cookable Profile Schema",
+  description: "Extends the base schema to require structured yield + time metadata and non-empty ingredient/instruction lists.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      required: ["yield", "time", "ingredients", "instructions"],
+      properties: {
+        yield: { $ref: "http://soustack.org/schema/v0.2.1#/definitions/yield" },
+        time: { $ref: "http://soustack.org/schema/v0.2.1#/definitions/time" },
+        ingredients: { type: "array", minItems: 1 },
+        instructions: { type: "array", minItems: 1 }
       }
-    } catch {
     }
-  }
-  if (jsonLdRecipe) {
-    return { recipe: jsonLdRecipe, source: "jsonld" };
-  }
-  const microdataRecipe = extractMicrodata(html);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:12", message: "Microdata extraction result", data: { hasMicrodata: !!microdataRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "D" }) }).catch(() => {
-        });
+  ]
+};
+
+// src/profiles/quantified.schema.json
+var quantified_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/quantified",
+  title: "Soustack Quantified Profile Schema",
+  description: "Extends the base schema to require quantified ingredient entries.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      properties: {
+        ingredients: {
+          type: "array",
+          items: {
+            anyOf: [
+              { $ref: "#/definitions/quantifiedIngredient" },
+              { $ref: "#/definitions/quantifiedIngredientSubsection" }
+            ]
+          }
+        }
       }
-    } catch {
+    }
+  ],
+  definitions: {
+    quantifiedIngredient: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/ingredient" },
+        { required: ["item", "quantity"] }
+      ]
+    },
+    quantifiedIngredientSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/ingredientSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              items: { $ref: "#/definitions/quantifiedIngredient" }
+            }
+          }
+        }
+      ]
     }
   }
-  if (microdataRecipe) {
-    return { recipe: microdataRecipe, source: "microdata" };
+};
+
+// src/profiles/illustrated.schema.json
+var illustrated_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/illustrated",
+  title: "Soustack Illustrated Profile Schema",
+  description: "Extends the base schema to guarantee at least one illustrative image.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      anyOf: [
+        { required: ["image"] },
+        {
+          properties: {
+            instructions: {
+              type: "array",
+              contains: {
+                anyOf: [
+                  { $ref: "#/definitions/imageInstruction" },
+                  { $ref: "#/definitions/instructionSubsectionWithImage" }
+                ]
+              }
+            }
+          }
+        }
+      ]
+    }
+  ],
+  definitions: {
+    imageInstruction: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instruction" },
+        { required: ["image"] }
+      ]
+    },
+    instructionSubsectionWithImage: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instructionSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              contains: { $ref: "#/definitions/imageInstruction" }
+            }
+          }
+        }
+      ]
+    }
   }
-  return { recipe: null, source: null };
-}
+};
 
-// src/scraper/index.ts
-async function scrapeRecipe(url, options = {}) {
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:7", message: "scrapeRecipe entry", data: { url, hasOptions: !!options }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,B,C,D,E" }) }).catch(() => {
-        });
+// src/profiles/schedulable.schema.json
+var schedulable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.2.1/profiles/schedulable",
+  title: "Soustack Schedulable Profile Schema",
+  description: "Extends the base schema to ensure every instruction is fully scheduled.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.2.1" },
+    {
+      properties: {
+        instructions: {
+          type: "array",
+          items: {
+            anyOf: [
+              { $ref: "#/definitions/schedulableInstruction" },
+              { $ref: "#/definitions/schedulableInstructionSubsection" }
+            ]
+          }
+        }
       }
-    } catch {
+    }
+  ],
+  definitions: {
+    schedulableInstruction: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instruction" },
+        { required: ["id", "timing"] }
+      ]
+    },
+    schedulableInstructionSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instructionSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              items: { $ref: "#/definitions/schedulableInstruction" }
+            }
+          }
+        }
+      ]
     }
   }
-  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 {
+};
+
+// src/validator.ts
+var profileSchemas = {
+  base: base_schema_default,
+  cookable: cookable_schema_default,
+  scalable: base_schema_default,
+  quantified: quantified_schema_default,
+  illustrated: illustrated_schema_default,
+  schedulable: schedulable_schema_default
+};
+var validationContexts = /* @__PURE__ */ new Map();
+function createContext(collectAllErrors) {
+  const ajv = new Ajv__default.default({ strict: false, allErrors: collectAllErrors });
+  addFormats__default.default(ajv);
+  const loadedIds = /* @__PURE__ */ new Set();
+  const addSchemaIfNew = (schema) => {
+    if (!schema) return;
+    const schemaId = schema?.$id;
+    if (schemaId && loadedIds.has(schemaId)) return;
+    ajv.addSchema(schema);
+    if (schemaId) loadedIds.add(schemaId);
+  };
+  addSchemaIfNew(schema_default);
+  addSchemaIfNew(soustack_schema_default);
+  Object.values(profileSchemas).forEach(addSchemaIfNew);
+  return { ajv, validators: {} };
+}
+function getContext(collectAllErrors) {
+  if (!validationContexts.has(collectAllErrors)) {
+    validationContexts.set(collectAllErrors, createContext(collectAllErrors));
+  }
+  return validationContexts.get(collectAllErrors);
+}
+function cloneRecipe(recipe) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(recipe);
+  }
+  return JSON.parse(JSON.stringify(recipe));
+}
+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 void 0;
+}
+function getValidator(profile, context) {
+  if (!profileSchemas[profile]) {
+    throw new Error(`Unknown Soustack profile: ${profile}`);
+  }
+  if (!context.validators[profile]) {
+    context.validators[profile] = context.ajv.compile(profileSchemas[profile]);
+  }
+  return context.validators[profile];
+}
+function normalizeRecipe(recipe) {
+  const normalized = cloneRecipe(recipe);
+  const warnings = [];
+  normalizeTime(normalized);
+  if (normalized && typeof normalized === "object" && "version" in normalized && !normalized.recipeVersion && typeof normalized.version === "string") {
+    normalized.recipeVersion = normalized.version;
+    warnings.push({ path: "/version", message: "'version' is deprecated; mapped to 'recipeVersion'." });
+  }
+  return { normalized, warnings };
+}
+function normalizeTime(recipe) {
+  const time = recipe?.time;
+  if (!time || typeof time !== "object" || Array.isArray(time)) return;
+  const structuredKeys = [
+    "prep",
+    "active",
+    "passive",
+    "total"
+  ];
+  structuredKeys.forEach((key) => {
+    const value = time[key];
+    if (typeof value === "number") return;
+    const parsed = parseDuration(value);
+    if (parsed !== null) {
+      time[key] = parsed;
     }
+  });
+}
+var allowedTopLevelProps = /* @__PURE__ */ new Set([
+  ...Object.keys(soustack_schema_default?.properties ?? {}),
+  "metadata",
+  "$schema"
+]);
+function detectUnknownTopLevelKeys(recipe) {
+  if (!recipe || typeof recipe !== "object") return [];
+  const disallowedKeys = Object.keys(recipe).filter(
+    (key) => !allowedTopLevelProps.has(key) && !key.startsWith("x-")
+  );
+  return disallowedKeys.map((key) => ({
+    path: `/${key}`,
+    keyword: "additionalProperties",
+    message: `Unknown top-level property '${key}' is not allowed by the Soustack spec`
+  }));
+}
+function formatAjvError(error) {
+  let path2 = error.instancePath || "/";
+  if (error.keyword === "additionalProperties" && error.params?.additionalProperty) {
+    const extra = error.params.additionalProperty;
+    path2 = `${error.instancePath || ""}/${extra}`.replace(/\/+/g, "/") || "/";
   }
-  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(() => {
-        });
+  return {
+    path: path2,
+    keyword: error.keyword,
+    message: error.message || "Validation error"
+  };
+}
+function runAjvValidation(data, profile, context, schemaRef) {
+  const validator = schemaRef ? context.ajv.getSchema(schemaRef) : void 0;
+  const validateFn = validator ?? getValidator(profile, context);
+  const isValid = validateFn(data);
+  return !isValid && validateFn.errors ? validateFn.errors.map(formatAjvError) : [];
+}
+function isInstruction(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && "text" in item;
+}
+function isInstructionSubsection(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && "items" in item && "subsection" in item;
+}
+function checkInstructionGraph(recipe) {
+  const instructions = recipe?.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;
       }
-    } catch {
+      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}'.`
+      });
     }
-  }
-  if (!recipe) {
-    throw new Error("No Schema.org recipe data found in page");
-  }
-  const soustackRecipe = fromSchemaOrg(recipe);
-  if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:17", message: "fromSchemaOrg result", data: { hasSoustackRecipe: !!soustackRecipe, soustackRecipeName: soustackRecipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
+  });
+  const adjacency = /* @__PURE__ */ new Map();
+  dependencyRefs.forEach((ref) => {
+    if (ref.fromId && instructionIds.has(ref.fromId) && instructionIds.has(ref.toId)) {
+      const list = adjacency.get(ref.fromId) ?? [];
+      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) => {
+    if (visiting.has(nodeId)) return;
+    if (visited.has(nodeId)) return;
+    visiting.add(nodeId);
+    const neighbors = adjacency.get(nodeId) ?? [];
+    neighbors.forEach((edge) => {
+      if (visiting.has(edge.toId)) {
+        errors.push({
+          path: edge.path,
+          message: `Circular dependency detected involving instruction id '${edge.toId}'.`
         });
+        return;
       }
-    } catch {
-    }
-  }
-  if (!soustackRecipe) {
-    throw new Error("Schema.org data did not include a valid recipe");
-  }
-  return soustackRecipe;
+      detectCycles(edge.toId);
+    });
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+  };
+  instructionIds.forEach((id) => detectCycles(id));
+  return errors;
+}
+function validateRecipe(input, options = {}) {
+  const collectAllErrors = options.collectAllErrors ?? true;
+  const context = getContext(collectAllErrors);
+  const schemaRef = options.schema ?? (typeof input?.$schema === "string" ? input.$schema : void 0);
+  const profile = options.profile ?? detectProfileFromSchema(schemaRef) ?? "base";
+  const { normalized, warnings } = normalizeRecipe(input);
+  const unknownKeyErrors = detectUnknownTopLevelKeys(normalized);
+  const validationErrors = runAjvValidation(normalized, profile, context, schemaRef);
+  const graphErrors = profile === "schedulable" && validationErrors.length === 0 ? checkInstructionGraph(normalized) : [];
+  const errors = [...unknownKeyErrors, ...validationErrors, ...graphErrors];
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    normalized: errors.length === 0 ? normalized : void 0
+  };
 }
 
 // bin/cli.ts
-var [, , command, ...args] = process.argv;
-async function main() {
+var supportedProfiles = ["base", "cookable", "scalable", "quantified", "illustrated", "schedulable"];
+async function runCli(argv) {
+  const [command, ...args] = argv;
   try {
     switch (command) {
       case "validate":
         await handleValidate(args);
-        break;
-      case "scale":
-        await handleScale(args);
-        break;
+        return;
+      case "convert":
+        await handleConvert(args);
+        return;
       case "import":
         await handleImport(args);
-        break;
-      case "export":
-        await handleExport(args);
-        break;
+        return;
+      case "scale":
+        await handleScale(args);
+        return;
       case "scrape":
         await handleScrape(args);
-        break;
+        return;
+      case "test":
+        await handleTest(args);
+        return;
       default:
         printUsage();
-        process.exit(1);
+        process.exitCode = 1;
     }
   } catch (error) {
-    console.error(`\u274C ${error.message}`);
+    console.error(`\u274C ${error?.message ?? error}`);
     process.exit(1);
   }
 }
 function printUsage() {
   console.log("Usage:");
-  console.log("  npx soustack validate <soustack.json>");
-  console.log("  npx soustack scale <soustack.json> <multiplier>");
-  console.log("  npx soustack import <schema-org.jsonld> -o <soustack.json>");
-  console.log("  npx soustack export <soustack.json> -o <schema-org.jsonld>");
-  console.log("  npx soustack scrape <url> -o <soustack.json>");
-}
-async function handleValidate(args2) {
-  const filePath = args2[0];
-  if (!filePath) throw new Error("Path to recipe JSON is required");
-  const recipe = readJsonFile(filePath);
-  validateRecipe(recipe);
-  console.log("\u2705 Valid Soustack Recipe");
+  console.log("  soustack validate <fileOrGlob> [--profile <name>] [--strict] [--json]");
+  console.log("  soustack convert --from <schemaorg|soustack> --to <schemaorg|soustack> <input> [-o <output>]");
+  console.log("  soustack import --url <url> [-o <soustack.json>]");
+  console.log("  soustack test [--profile <name>] [--strict] [--json]");
+  console.log("  soustack scale <soustack.json> <multiplier>");
+  console.log("  soustack scrape <url> -o <soustack.json>");
+}
+async function handleValidate(args) {
+  const { target, profile, strict, json } = parseValidateArgs(args);
+  if (!target) throw new Error("Path or glob to Soustack recipe JSON is required");
+  const files = expandTargets(target);
+  if (files.length === 0) throw new Error(`No files matched pattern: ${target}`);
+  const results = files.map((file) => validateFile(file, profile));
+  reportValidation(results, { strict, json });
+}
+async function handleTest(args) {
+  const { profile, strict, json } = parseValidationFlags(args);
+  const cwd = process.cwd();
+  const files = glob.globSync("**/*.soustack.json", {
+    cwd,
+    absolute: true,
+    nodir: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"]
+  }).map((file) => path__namespace.resolve(cwd, file));
+  if (files.length === 0) {
+    console.log("No *.soustack.json files found in the current repository.");
+    return;
+  }
+  const results = files.map((file) => validateFile(file, profile));
+  reportValidation(results, { strict, json, context: "test" });
+}
+async function handleConvert(args) {
+  const { from, to, inputPath, outputPath } = parseConvertArgs(args);
+  const fromKey = from?.toLowerCase();
+  const toKey = to?.toLowerCase();
+  if (!inputPath || !fromKey || !toKey) {
+    throw new Error("Convert usage: convert --from <schemaorg|soustack> --to <schemaorg|soustack> <input> [-o <output>]");
+  }
+  const direction = resolveConvertDirection(fromKey, toKey);
+  if (!direction) {
+    throw new Error(`Unsupported conversion from "${from}" to "${to}"`);
+  }
+  const input = readJsonFile(inputPath);
+  const result = direction === "schemaorg-to-soustack" ? fromSchemaOrg(input) : toSchemaOrg(input);
+  if (!result) {
+    throw new Error("Unable to convert input with the provided formats.");
+  }
+  writeOutput(result, outputPath);
+  console.log(`\u2705 Converted ${fromKey} \u2192 ${toKey}${outputPath ? ` (${outputPath})` : ""}`);
+}
+async function handleImport(args) {
+  const { url, outputPath } = parseImportArgs(args);
+  if (!url) throw new Error("Import usage: import --url <url> [-o <soustack.json>]");
+  const recipe = await scrapeRecipe(url);
+  writeOutput(recipe, outputPath);
+  console.log(`\u2705 Imported recipe from ${url}${outputPath ? ` (${outputPath})` : ""}`);
 }
-async function handleScale(args2) {
-  const filePath = args2[0];
-  const multiplier = args2[1] ? parseFloat(args2[1]) : 1;
+async function handleScale(args) {
+  const filePath = args[0];
+  const multiplier = args[1] ? parseFloat(args[1]) : 1;
   if (!filePath || Number.isNaN(multiplier)) {
     throw new Error("Scale usage: scale <soustack.json> <multiplier>");
   }
   const recipe = readJsonFile(filePath);
   console.log(`
-\u2696\uFE0F  Scaling "${recipe.name}" by ${multiplier}x...
+\u2696\uFE0F  Scaling "${recipe?.name ?? filePath}" by ${multiplier}x...
 `);
-  const baseYield = recipe.yield?.amount || 1;
-  const targetYield = baseYield * multiplier;
-  const result = scaleRecipe(recipe, targetYield);
-  console.log("--- INGREDIENTS ---");
-  result.ingredients.forEach((ing) => {
-    console.log(`\u2022 ${ing.text}`);
-  });
-  console.log("\n--- TIMING ---");
-  console.log(`Total Time: ${result.timing.total} minutes`);
-  console.log(`(Active: ${result.timing.active}m | Passive: ${result.timing.passive}m)`);
-}
-async function handleImport(args2) {
-  const filePath = args2[0];
-  const outputPath = resolveOutputPath(args2.slice(1));
-  if (!filePath) throw new Error("Import usage: import <schema-org.json> -o <soustack.json>");
-  const schemaOrg = readJsonFile(filePath);
-  const soustack = fromSchemaOrg(schemaOrg);
-  if (!soustack) {
-    throw new Error("No valid Schema.org recipe found in input");
-  }
-  writeOutput(soustack, outputPath);
-  console.log(`\u2705 Converted Schema.org \u2192 Soustack${outputPath ? ` (${outputPath})` : ""}`);
-}
-async function handleExport(args2) {
-  const filePath = args2[0];
-  const outputPath = resolveOutputPath(args2.slice(1));
-  if (!filePath) throw new Error("Export usage: export <soustack.json> -o <schema-org.jsonld>");
-  const soustack = readJsonFile(filePath);
-  const schemaOrg = toSchemaOrg(soustack);
-  writeOutput(schemaOrg, outputPath);
-  console.log(`\u2705 Converted Soustack \u2192 Schema.org${outputPath ? ` (${outputPath})` : ""}`);
-}
-async function handleScrape(args2) {
-  const url = args2[0];
-  const outputPath = resolveOutputPath(args2.slice(1));
+  const result = scaleRecipe(recipe, { multiplier });
+  console.log(JSON.stringify(result, null, 2));
+}
+async function handleScrape(args) {
+  const url = args[0];
+  const outputPath = resolveOutputPath(args.slice(1));
   if (!url) throw new Error("Scrape usage: scrape <url> -o <soustack.json>");
   const recipe = await scrapeRecipe(url);
   writeOutput(recipe, outputPath);
   console.log(`\u2705 Scraped recipe from ${url}${outputPath ? ` (${outputPath})` : ""}`);
 }
+function parseValidateArgs(args) {
+  let profile;
+  let strict = false;
+  let json = false;
+  let target;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--profile":
+        profile = normalizeProfile(args[i + 1]);
+        i++;
+        break;
+      case "--strict":
+        strict = true;
+        break;
+      case "--json":
+        json = true;
+        break;
+      default:
+        if (!arg.startsWith("--") && !target) {
+          target = arg;
+        }
+        break;
+    }
+  }
+  return { profile, strict, json, target };
+}
+function parseValidationFlags(args) {
+  const { profile, strict, json } = parseValidateArgs(args);
+  return { profile, strict, json };
+}
+function normalizeProfile(value) {
+  if (!value) return void 0;
+  const normalized = value.toLowerCase();
+  if (supportedProfiles.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Unknown Soustack profile: ${value}`);
+}
+function parseConvertArgs(args) {
+  let from;
+  let to;
+  let outputPath;
+  let inputPath;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--from":
+        from = args[i + 1];
+        if (!from) throw new Error("Missing value for --from");
+        i++;
+        break;
+      case "--to":
+        to = args[i + 1];
+        if (!to) throw new Error("Missing value for --to");
+        i++;
+        break;
+      case "-o":
+      case "--output":
+        outputPath = args[i + 1];
+        if (!outputPath) throw new Error("Missing value for output");
+        i++;
+        break;
+      default:
+        if (!inputPath && !arg.startsWith("--")) {
+          inputPath = arg;
+        }
+        break;
+    }
+  }
+  return { from, to, inputPath, outputPath };
+}
+function parseImportArgs(args) {
+  let url;
+  let outputPath;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--url") {
+      url = args[i + 1];
+      if (!url) {
+        throw new Error("URL flag provided without a value");
+      }
+      i++;
+    } else if (arg === "-o" || arg === "--output") {
+      outputPath = args[i + 1];
+      if (!outputPath) {
+        throw new Error("Output flag provided without a path");
+      }
+      i++;
+    }
+  }
+  return { url, outputPath };
+}
+function resolveConvertDirection(from, to) {
+  if (from === "schemaorg" && to === "soustack") return "schemaorg-to-soustack";
+  if (from === "soustack" && to === "schemaorg") return "soustack-to-schemaorg";
+  return null;
+}
+function expandTargets(target) {
+  const matches = glob.globSync(target, { absolute: true, nodir: true });
+  const unique = Array.from(new Set(matches.map((match) => path__namespace.resolve(match))));
+  return unique;
+}
+function validateFile(file, profile) {
+  const recipe = readJsonFile(file);
+  const result = validateRecipe(recipe, profile ? { profile } : {});
+  return {
+    file,
+    profile,
+    valid: result.valid,
+    warnings: result.warnings,
+    errors: result.errors
+  };
+}
+function reportValidation(results, options) {
+  const summary = {
+    strict: options.strict,
+    total: results.length,
+    passed: 0,
+    failed: 0
+  };
+  const serializable = results.map((result) => {
+    const passed = isEffectivelyValid(result, options.strict);
+    if (passed) summary.passed += 1;
+    else summary.failed += 1;
+    return {
+      file: path__namespace.relative(process.cwd(), result.file),
+      profile: result.profile,
+      valid: result.valid,
+      warnings: result.warnings,
+      errors: result.errors,
+      passed
+    };
+  });
+  if (options.json) {
+    console.log(JSON.stringify({ summary, results: serializable }, null, 2));
+  } else {
+    serializable.forEach((entry) => {
+      const prefix = entry.passed ? "\u2705" : "\u274C";
+      console.log(`${prefix} ${entry.file}`);
+      if (!entry.passed && entry.errors.length) {
+        entry.errors.forEach((error) => {
+          console.log(`   \u2022 [${error.path}] ${error.message}`);
+        });
+      }
+      if (!entry.passed && options.strict && entry.warnings.length) {
+        entry.warnings.forEach((warning) => {
+          console.log(`   \u2022 [${warning.path}] ${warning.message} (warning)`);
+        });
+      }
+    });
+    const contextLabel = options.context === "test" ? "Test summary" : "Validation summary";
+    console.log(`${contextLabel}: ${summary.passed}/${summary.total} files valid${options.strict ? " (strict)" : ""}`);
+  }
+  if (summary.failed > 0) {
+    process.exitCode = 1;
+  }
+}
+function isEffectivelyValid(result, strict) {
+  return result.valid && (!strict || result.warnings.length === 0);
+}
 function readJsonFile(relativePath) {
   const absolutePath = path__namespace.resolve(relativePath);
   if (!fs__namespace.existsSync(absolutePath)) {
@@ -2254,10 +2587,10 @@ function readJsonFile(relativePath) {
     throw new Error(`Unable to parse JSON in ${absolutePath}`);
   }
 }
-function resolveOutputPath(args2) {
-  const index = args2.findIndex((arg) => arg === "-o" || arg === "--output");
+function resolveOutputPath(args) {
+  const index = args.findIndex((arg) => arg === "-o" || arg === "--output");
   if (index === -1) return void 0;
-  const target = args2[index + 1];
+  const target = args[index + 1];
   if (!target) {
     throw new Error("Output flag provided without a path");
   }
@@ -2272,6 +2605,13 @@ function writeOutput(data, outputPath) {
   const absolutePath = path__namespace.resolve(outputPath);
   fs__namespace.writeFileSync(absolutePath, serialized, "utf-8");
 }
-main();
+if (__require.main === module) {
+  runCli(process.argv.slice(2)).catch((error) => {
+    console.error(`\u274C ${error?.message ?? error}`);
+    process.exit(1);
+  });
+}
+
+exports.runCli = runCli;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map