soustack 0.2.3 → 0.4.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import Ajv from 'ajv';
+import Ajv2020 from 'ajv/dist/2020';
 import addFormats from 'ajv-formats';
 
 // src/parsers/duration.ts
@@ -95,17 +95,17 @@ function scaleRecipe(recipe, options = {}) {
   const orderedIngredients = [];
   collectIngredients(scaled.ingredients || [], orderedIngredients);
   orderedIngredients.filter((ing) => {
-    var _a2;
-    return (((_a2 = ing.scaling) == null ? void 0 : _a2.type) || "linear") !== "bakers_percentage";
+    var _a;
+    return (((_a = ing.scaling) == null ? void 0 : _a.type) || "linear") !== "bakers_percentage";
   }).forEach((ing) => {
     const key = getIngredientKey(ing);
     scaledAmounts.set(key, calculateIndependentIngredient(ing, multiplier));
   });
   orderedIngredients.filter((ing) => {
-    var _a2;
-    return ((_a2 = ing.scaling) == null ? void 0 : _a2.type) === "bakers_percentage";
+    var _a;
+    return ((_a = ing.scaling) == null ? void 0 : _a.type) === "bakers_percentage";
   }).forEach((ing) => {
-    var _a2, _b2;
+    var _a, _b;
     const key = getIngredientKey(ing);
     const scaling = ing.scaling;
     if (!(scaling == null ? void 0 : scaling.referenceId)) {
@@ -115,9 +115,9 @@ function scaleRecipe(recipe, options = {}) {
     if (referenceAmount === void 0) {
       throw new Error(`Reference ingredient "${scaling.referenceId}" not found for baker's percentage item "${key}"`);
     }
-    const baseAmount = ((_a2 = ing.quantity) == null ? void 0 : _a2.amount) || 0;
+    const baseAmount = ((_a = ing.quantity) == null ? void 0 : _a.amount) || 0;
     const referenceBase = baseAmounts.get(scaling.referenceId);
-    const factor = (_b2 = scaling.factor) != null ? _b2 : referenceBase ? baseAmount / referenceBase : void 0;
+    const factor = (_b = scaling.factor) != null ? _b : referenceBase ? baseAmount / referenceBase : void 0;
     if (factor === void 0) {
       throw new Error(`Unable to determine factor for baker's percentage ingredient "${key}"`);
     }
@@ -137,19 +137,19 @@ function scaleRecipe(recipe, options = {}) {
   return scaled;
 }
 function resolveMultiplier(recipe, options) {
-  var _a2, _b2;
+  var _a, _b;
   if (options.multiplier && options.multiplier > 0) {
     return options.multiplier;
   }
-  if ((_a2 = options.targetYield) == null ? void 0 : _a2.amount) {
-    const base = ((_b2 = recipe.yield) == null ? void 0 : _b2.amount) || 1;
+  if ((_a = options.targetYield) == null ? void 0 : _a.amount) {
+    const base = ((_b = recipe.yield) == null ? void 0 : _b.amount) || 1;
     return options.targetYield.amount / base;
   }
   return 1;
 }
 function applyYieldScaling(recipe, options, multiplier) {
-  var _a2, _b2, _c, _d, _e, _f, _g;
-  const baseAmount = (_b2 = (_a2 = recipe.yield) == null ? void 0 : _a2.amount) != null ? _b2 : 1;
+  var _a, _b, _c, _d, _e, _f, _g;
+  const baseAmount = (_b = (_a = recipe.yield) == null ? void 0 : _a.amount) != null ? _b : 1;
   const targetAmount = (_d = (_c = options.targetYield) == null ? void 0 : _c.amount) != null ? _d : baseAmount * multiplier;
   const unit = (_g = (_e = options.targetYield) == null ? void 0 : _e.unit) != null ? _g : (_f = recipe.yield) == null ? void 0 : _f.unit;
   if (!recipe.yield && !options.targetYield) return;
@@ -162,9 +162,9 @@ function getIngredientKey(ing) {
   return ing.id || ing.item;
 }
 function calculateIndependentIngredient(ing, multiplier) {
-  var _a2, _b2, _c, _d, _e, _f;
-  const baseAmount = ((_a2 = ing.quantity) == null ? void 0 : _a2.amount) || 0;
-  const type = ((_b2 = ing.scaling) == null ? void 0 : _b2.type) || "linear";
+  var _a, _b, _c, _d, _e, _f;
+  const baseAmount = ((_a = ing.quantity) == null ? void 0 : _a.amount) || 0;
+  const type = ((_b = ing.scaling) == null ? void 0 : _b.type) || "linear";
   switch (type) {
     case "fixed":
       return baseAmount;
@@ -194,12 +194,12 @@ function collectIngredients(items, bucket) {
 }
 function collectBaseIngredientAmounts(items, map = /* @__PURE__ */ new Map()) {
   items.forEach((item) => {
-    var _a2, _b2;
+    var _a, _b;
     if (typeof item === "string") return;
     if ("subsection" in item) {
       collectBaseIngredientAmounts(item.items, map);
     } else {
-      map.set(getIngredientKey(item), (_b2 = (_a2 = item.quantity) == null ? void 0 : _a2.amount) != null ? _b2 : 0);
+      map.set(getIngredientKey(item), (_b = (_a = item.quantity) == null ? void 0 : _a.amount) != null ? _b : 0);
     }
   });
   return map;
@@ -240,11 +240,321 @@ function toDurationMinutes(duration) {
   return 0;
 }
 
-// src/schema.json
-var schema_default = {
+// src/normalize.ts
+function normalizeRecipe(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("Recipe input must be an object");
+  }
+  const recipe = JSON.parse(JSON.stringify(input));
+  const warnings = [];
+  const legacyField = ["mod", "ules"].join("");
+  if (legacyField in recipe) {
+    throw new Error("The legacy field is no longer supported. Use `stacks` instead.");
+  }
+  normalizeStacks(recipe, warnings);
+  if (!recipe.stacks) {
+    recipe.stacks = {};
+  }
+  if (recipe && typeof recipe === "object" && "version" in recipe && !recipe.recipeVersion && typeof recipe.version === "string") {
+    recipe.recipeVersion = recipe.version;
+    warnings.push("'version' is deprecated; mapped to 'recipeVersion'.");
+  }
+  normalizeTime(recipe);
+  return {
+    recipe,
+    warnings
+  };
+}
+function normalizeStacks(recipe, warnings) {
+  let stacks = {};
+  if (recipe.stacks && typeof recipe.stacks === "object" && !Array.isArray(recipe.stacks)) {
+    for (const [key, value] of Object.entries(recipe.stacks)) {
+      if (typeof value === "number" && Number.isInteger(value) && value >= 1) {
+        stacks[key] = value;
+      } else {
+        warnings.push(`Invalid stack version for '${key}': expected positive integer, got ${value}`);
+      }
+    }
+  }
+  if (Array.isArray(recipe.stacks)) {
+    const stackIdentifiers = recipe.stacks.filter((s) => typeof s === "string");
+    for (const identifier of stackIdentifiers) {
+      const parsed = parseStackIdentifier(identifier);
+      if (parsed) {
+        const { name, version } = parsed;
+        if (!stacks[name] || stacks[name] < version) {
+          stacks[name] = version;
+        }
+      } else {
+        warnings.push(`Invalid stack identifier '${identifier}': expected format 'name@version' (e.g., 'scaling@1')`);
+      }
+    }
+  }
+  recipe.stacks = stacks;
+}
+function parseStackIdentifier(identifier) {
+  if (typeof identifier !== "string" || !identifier.trim()) {
+    return null;
+  }
+  const match = identifier.trim().match(/^([a-z0-9_-]+)@(\d+)$/i);
+  if (!match) {
+    return null;
+  }
+  const [, name, versionStr] = match;
+  const version = parseInt(versionStr, 10);
+  if (isNaN(version) || version < 1) {
+    return null;
+  }
+  return { name, version };
+}
+function normalizeTime(recipe) {
+  const time = recipe == null ? void 0 : recipe.time;
+  if (!time || typeof time !== "object" || Array.isArray(time)) return;
+  const structuredKeys = [
+    "prep",
+    "active",
+    "passive",
+    "total"
+  ];
+  structuredKeys.forEach((key) => {
+    const value = time[key];
+    if (typeof value === "number") return;
+    const parsed = parseDuration(value);
+    if (parsed !== null) {
+      time[key] = parsed;
+    }
+  });
+}
+
+// src/conformance/index.ts
+function validateConformance(recipe) {
+  const issues = [];
+  issues.push(...checkDAGValidity(recipe));
+  if (hasSchedulableProfile(recipe)) {
+    issues.push(...checkTimingSchedulability(recipe));
+  }
+  issues.push(...checkScalingSanity(recipe));
+  const ok = issues.filter((i) => i.severity === "error").length === 0;
+  return { ok, issues };
+}
+function hasSchedulableProfile(recipe) {
+  const schema = recipe.$schema;
+  if (typeof schema === "string") {
+    return schema.includes("schedulable") || schema === "http://soustack.org/schema/v0.3.0/profiles/schedulable";
+  }
+  return false;
+}
+function checkDAGValidity(recipe) {
+  const issues = [];
+  const instructions = recipe.instructions;
+  if (!Array.isArray(instructions)) {
+    return issues;
+  }
+  const instructionIds = /* @__PURE__ */ new Set();
+  const dependencyRefs = [];
+  const collect = (items, basePath) => {
+    items.forEach((item, index) => {
+      const currentPath = `${basePath}/${index}`;
+      if (isInstructionSubsection(item)) {
+        if (Array.isArray(item.items)) {
+          collect(item.items, `${currentPath}/items`);
+        }
+        return;
+      }
+      if (isInstruction(item)) {
+        const id = typeof item.id === "string" ? item.id : void 0;
+        if (id) {
+          instructionIds.add(id);
+        }
+        if (Array.isArray(item.dependsOn)) {
+          item.dependsOn.forEach((depId, depIndex) => {
+            if (typeof depId === "string") {
+              dependencyRefs.push({
+                fromId: id,
+                toId: depId,
+                path: `${currentPath}/dependsOn/${depIndex}`
+              });
+            }
+          });
+        }
+      }
+    });
+  };
+  collect(instructions, "/instructions");
+  dependencyRefs.forEach((ref) => {
+    if (!instructionIds.has(ref.toId)) {
+      issues.push({
+        code: "DAG_MISSING_NODE",
+        path: ref.path,
+        message: `Instruction dependency references missing step id '${ref.toId}'.`,
+        severity: "error"
+      });
+    }
+  });
+  const adjacency = /* @__PURE__ */ new Map();
+  dependencyRefs.forEach((ref) => {
+    var _a;
+    if (ref.fromId && instructionIds.has(ref.fromId) && instructionIds.has(ref.toId)) {
+      const list = (_a = adjacency.get(ref.fromId)) != null ? _a : [];
+      list.push({ toId: ref.toId, path: ref.path });
+      adjacency.set(ref.fromId, list);
+    }
+  });
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const detectCycles = (nodeId) => {
+    var _a;
+    if (visiting.has(nodeId)) {
+      return;
+    }
+    if (visited.has(nodeId)) {
+      return;
+    }
+    visiting.add(nodeId);
+    const neighbors = (_a = adjacency.get(nodeId)) != null ? _a : [];
+    neighbors.forEach((edge) => {
+      if (visiting.has(edge.toId)) {
+        issues.push({
+          code: "DAG_CYCLE",
+          path: edge.path,
+          message: `Circular dependency detected involving step id '${edge.toId}'.`,
+          severity: "error"
+        });
+        return;
+      }
+      detectCycles(edge.toId);
+    });
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+  };
+  instructionIds.forEach((id) => detectCycles(id));
+  return issues;
+}
+function checkTimingSchedulability(recipe) {
+  const issues = [];
+  const instructions = recipe.instructions;
+  if (!Array.isArray(instructions)) {
+    return issues;
+  }
+  const checkInstruction = (item, path) => {
+    if (isInstructionSubsection(item)) {
+      if (Array.isArray(item.items)) {
+        item.items.forEach((subItem, index) => {
+          checkInstruction(subItem, `${path}/items/${index}`);
+        });
+      }
+      return;
+    }
+    if (isInstruction(item)) {
+      if (!item.id) {
+        issues.push({
+          code: "SCHEDULABLE_MISSING_ID",
+          path,
+          message: "Schedulable profile requires all instructions to have an id.",
+          severity: "error"
+        });
+      }
+      if (!item.timing) {
+        issues.push({
+          code: "SCHEDULABLE_MISSING_TIMING",
+          path,
+          message: "Schedulable profile requires all instructions to have timing information.",
+          severity: "error"
+        });
+      } else if (!item.timing.duration) {
+        issues.push({
+          code: "SCHEDULABLE_MISSING_DURATION",
+          path: `${path}/timing`,
+          message: "Schedulable profile requires timing.duration for all instructions.",
+          severity: "error"
+        });
+      }
+    }
+  };
+  instructions.forEach((item, index) => {
+    checkInstruction(item, `/instructions/${index}`);
+  });
+  return issues;
+}
+function checkScalingSanity(recipe) {
+  const issues = [];
+  const ingredients = recipe.ingredients;
+  if (!Array.isArray(ingredients)) {
+    return issues;
+  }
+  const ingredientIds = /* @__PURE__ */ new Set();
+  const collectIngredientIds = (items, basePath) => {
+    items.forEach((item, index) => {
+      if (isIngredientSubsection(item)) {
+        if (Array.isArray(item.items)) {
+          collectIngredientIds(item.items);
+        }
+        return;
+      }
+      if (isIngredient(item)) {
+        if (typeof item.id === "string") {
+          ingredientIds.add(item.id);
+        }
+      }
+    });
+  };
+  collectIngredientIds(ingredients);
+  const checkIngredient = (item, path) => {
+    if (isIngredientSubsection(item)) {
+      if (Array.isArray(item.items)) {
+        item.items.forEach((subItem, index) => {
+          checkIngredient(subItem, `${path}/items/${index}`);
+        });
+      }
+      return;
+    }
+    if (isIngredient(item)) {
+      const scaling = item.scaling;
+      if (scaling && typeof scaling === "object" && "type" in scaling && scaling.type === "bakers_percentage") {
+        const bakersScaling = scaling;
+        if (bakersScaling.referenceId) {
+          if (!ingredientIds.has(bakersScaling.referenceId)) {
+            issues.push({
+              code: "SCALING_INVALID_REFERENCE",
+              path: `${path}/scaling/referenceId`,
+              message: `Baker's percentage references missing ingredient id '${bakersScaling.referenceId}'.`,
+              severity: "error"
+            });
+          }
+        } else {
+          issues.push({
+            code: "SCALING_MISSING_REFERENCE",
+            path: `${path}/scaling`,
+            message: "Baker's percentage scaling requires a referenceId.",
+            severity: "error"
+          });
+        }
+      }
+    }
+  };
+  ingredients.forEach((item, index) => {
+    checkIngredient(item, `/ingredients/${index}`);
+  });
+  return issues;
+}
+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 isIngredient(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && "item" in item;
+}
+function isIngredientSubsection(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && "items" in item && "subsection" in item;
+}
+
+// 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",
+  $id: "http://soustack.org/schema/v0.3.0",
+  title: "Soustack Recipe Schema v0.3.0",
   description: "A portable, scalable, interoperable recipe format.",
   type: "object",
   required: ["name", "ingredients", "instructions"],
@@ -392,7 +702,10 @@ var schema_default = {
       required: ["amount"],
       properties: {
         amount: { type: "number" },
-        unit: { type: ["string", "null"] }
+        unit: {
+          type: ["string", "null"],
+          description: "Display-friendly unit text; implementations may normalize or canonicalize units separately."
+        }
       }
     },
     scaling: {
@@ -427,7 +740,16 @@ var schema_default = {
         aisle: { type: "string" },
         prep: { type: "string" },
         prepAction: { type: "string" },
+        prepActions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Structured prep verbs (e.g., peel, dice) for mise en place workflows."
+        },
         prepTime: { type: "number" },
+        form: {
+          type: "string",
+          description: "State of the ingredient as used (packed, sifted, melted, room_temperature, etc.)."
+        },
         destination: { type: "string" },
         scaling: { $ref: "#/definitions/scaling" },
         critical: { type: "boolean" },
@@ -586,548 +908,823 @@ var schema_default = {
   }
 };
 
-// src/soustack.schema.json
-var soustack_schema_default = {
+// src/schemas/recipe/base.schema.json
+var base_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2.1",
-  title: "Soustack Recipe Schema v0.2.1",
-  description: "A portable, scalable, interoperable recipe format.",
+  $id: "http://soustack.org/schema/recipe/base.schema.json",
+  title: "Soustack Recipe Base Schema",
+  description: "Base document shape for Soustack recipe documents. Profiles and stacks build on this baseline.",
   type: "object",
-  required: ["name", "ingredients", "instructions"],
-  additionalProperties: false,
-  patternProperties: {
-    "^x-": {}
-  },
+  additionalProperties: true,
   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"
+    "@type": {
+      const: "Recipe",
+      description: "Document marker for Soustack recipes"
     },
-    title: {
+    profile: {
       type: "string",
-      description: "Optional display title; alias for name"
+      description: "Profile identifier applied to this recipe"
     },
-    version: {
-      type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "DEPRECATED: use recipeVersion for authoring revisions"
+    stacks: {
+      type: "object",
+      description: "Stack declarations as a map: Record<stackName, versionNumber>",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
-    recipeVersion: {
+    name: {
       type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
-    },
-    description: {
-      type: "string"
+      description: "Human-readable recipe name"
     },
-    category: {
-      type: "string",
-      examples: ["Main Course", "Dessert"]
+    ingredients: {
+      type: "array",
+      description: "Ingredients payload; content is validated by profiles/stacks"
     },
-    tags: {
+    instructions: {
       type: "array",
-      items: { type: "string" }
+      description: "Instruction payload; content is validated by profiles/stacks"
+    }
+  },
+  required: ["@type"]
+};
+
+// src/schemas/recipe/profiles/minimal.schema.json
+var minimal_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/recipe/profiles/minimal.schema.json",
+  title: "Soustack Recipe Minimal Profile",
+  description: "Minimal profile that ensures the basic Recipe structure is present while allowing stacks to extend it.",
+  allOf: [
+    {
+      $ref: "http://soustack.org/schema/recipe/base.schema.json"
     },
-    image: {
-      description: "Recipe-level hero image(s)",
-      anyOf: [
-        {
+    {
+      type: "object",
+      properties: {
+        profile: {
+          const: "minimal"
+        },
+        stacks: {
+          type: "object",
+          additionalProperties: {
+            type: "integer",
+            minimum: 1
+          },
+          properties: {
+            attribution: { type: "integer", minimum: 1 },
+            taxonomy: { type: "integer", minimum: 1 },
+            media: { type: "integer", minimum: 1 },
+            nutrition: { type: "integer", minimum: 1 },
+            times: { type: "integer", minimum: 1 }
+          }
+        },
+        name: {
           type: "string",
-          format: "uri"
+          minLength: 1
         },
-        {
+        ingredients: {
           type: "array",
-          minItems: 1,
-          items: {
-            type: "string",
-            format: "uri"
-          }
+          minItems: 1
+        },
+        instructions: {
+          type: "array",
+          minItems: 1
         }
-      ]
-    },
-    dateAdded: {
-      type: "string",
-      format: "date-time"
-    },
-    metadata: {
-      type: "object",
-      additionalProperties: true,
-      description: "Free-form vendor metadata"
-    },
-    source: {
+      },
+      required: [
+        "profile",
+        "name",
+        "ingredients",
+        "instructions"
+      ],
+      additionalProperties: true
+    }
+  ]
+};
+
+// src/schemas/recipe/profiles/core.schema.json
+var core_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/recipe/profiles/core.schema.json",
+  title: "Soustack Recipe Core Profile",
+  description: "Core profile that builds on the minimal profile and is intended to be combined with recipe stacks.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/recipe/base.schema.json" },
+    {
       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"]
+        profile: { const: "core" },
+        stacks: {
+          type: "object",
+          additionalProperties: {
+            type: "integer",
+            minimum: 1
+          }
         },
-        factor: { type: "number" },
-        referenceId: { type: "string" },
-        roundTo: { type: "number" },
-        min: { type: "number" },
-        max: { type: "number" }
-      },
-      if: {
-        properties: { type: { const: "bakers_percentage" } }
+        name: { type: "string", minLength: 1 },
+        ingredients: { type: "array", minItems: 1 },
+        instructions: { type: "array", minItems: 1 }
       },
-      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"],
+      required: ["profile", "name", "ingredients", "instructions"],
+      additionalProperties: true
+    }
+  ]
+};
+
+// spec/profiles/base.schema.json
+var base_schema_default2 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.3.0/profiles/base",
+  title: "Soustack Base Profile Schema",
+  description: "Wrapper schema that exposes the unmodified Soustack base schema.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.3.0" }
+  ]
+};
+
+// spec/profiles/cookable.schema.json
+var cookable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.3.0/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.3.0" },
+    {
+      required: ["yield", "time", "ingredients", "instructions"],
       properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: { $ref: "#/definitions/ingredient" }
-        }
+        yield: { $ref: "http://soustack.org/schema/v0.3.0#/definitions/yield" },
+        time: { $ref: "http://soustack.org/schema/v0.3.0#/definitions/time" },
+        ingredients: { type: "array", minItems: 1 },
+        instructions: { type: "array", minItems: 1 }
       }
-    },
-    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" }
+    }
+  ]
+};
+
+// spec/profiles/illustrated.schema.json
+var illustrated_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.3.0/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.3.0" },
+    {
+      anyOf: [
+        { required: ["image"] },
+        {
+          properties: {
+            instructions: {
+              type: "array",
+              contains: {
+                anyOf: [
+                  { $ref: "#/definitions/imageInstruction" },
+                  { $ref: "#/definitions/instructionSubsectionWithImage" }
+                ]
+              }
+            }
+          }
         }
-      }
+      ]
+    }
+  ],
+  definitions: {
+    imageInstruction: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/instruction" },
+        { required: ["image"] }
+      ]
     },
-    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"],
+    instructionSubsectionWithImage: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/instructionSubsection" },
+        {
           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"] }
+            items: {
+              type: "array",
+              contains: { $ref: "#/definitions/imageInstruction" }
+            }
           }
         }
-      }
-    },
-    instructionSubsection: {
-      type: "object",
-      required: ["subsection", "items"],
+      ]
+    }
+  }
+};
+
+// spec/profiles/quantified.schema.json
+var quantified_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.3.0/profiles/quantified",
+  title: "Soustack Quantified Profile Schema",
+  description: "Extends the base schema to require quantified ingredient entries.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.3.0" },
+    {
       properties: {
-        subsection: { type: "string" },
-        items: {
+        ingredients: {
           type: "array",
           items: {
             anyOf: [
-              { type: "string" },
-              { $ref: "#/definitions/instruction" }
+              { $ref: "#/definitions/quantifiedIngredient" },
+              { $ref: "#/definitions/quantifiedIngredientSubsection" }
             ]
           }
         }
       }
+    }
+  ],
+  definitions: {
+    quantifiedIngredient: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/ingredient" },
+        { required: ["item", "quantity"] }
+      ]
     },
-    storage: {
-      type: "object",
+    quantifiedIngredientSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/ingredientSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              items: { $ref: "#/definitions/quantifiedIngredient" }
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+
+// spec/profiles/scalable.schema.json
+var scalable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.3.0/profiles/scalable",
+  title: "Soustack Scalable Profile Schema",
+  description: "Extends the base schema to guarantee quantified ingredients plus a structured yield for deterministic scaling.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/v0.3.0" },
+    {
+      required: ["yield", "ingredients"],
       properties: {
-        roomTemp: { $ref: "#/definitions/storageMethod" },
-        refrigerated: { $ref: "#/definitions/storageMethod" },
-        frozen: {
+        yield: {
           allOf: [
-            { $ref: "#/definitions/storageMethod" },
-            {
-              type: "object",
-              properties: { thawing: { type: "string" } }
-            }
+            { $ref: "http://soustack.org/schema/v0.3.0#/definitions/yield" },
+            { properties: { amount: { type: "number", exclusiveMinimum: 0 } } }
           ]
         },
-        reheating: { type: "string" },
-        makeAhead: {
+        ingredients: {
           type: "array",
+          minItems: 1,
           items: {
-            allOf: [
-              { $ref: "#/definitions/storageMethod" },
-              {
+            anyOf: [
+              { $ref: "#/definitions/scalableIngredient" },
+              { $ref: "#/definitions/scalableIngredientSubsection" }
+            ]
+          }
+        }
+      }
+    }
+  ],
+  definitions: {
+    scalableIngredient: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/ingredient" },
+        { required: ["item", "quantity"] },
+        {
+          properties: {
+            quantity: {
+              allOf: [
+                { $ref: "http://soustack.org/schema/v0.3.0#/definitions/quantity" },
+                { properties: { amount: { type: "number", exclusiveMinimum: 0 } } }
+              ]
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              scaling: {
                 type: "object",
-                required: ["component", "storage"],
-                properties: {
-                  component: { type: "string" },
-                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
-                }
+                properties: { type: { const: "bakers_percentage" } },
+                required: ["type"]
               }
+            },
+            required: ["scaling"]
+          },
+          then: { required: ["id"] }
+        }
+      ]
+    },
+    scalableIngredientSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/ingredientSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              minItems: 1,
+              items: { $ref: "#/definitions/scalableIngredient" }
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+
+// spec/profiles/schedulable.schema.json
+var schedulable_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/v0.3.0/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.3.0" },
+    {
+      properties: {
+        instructions: {
+          type: "array",
+          items: {
+            anyOf: [
+              { $ref: "#/definitions/schedulableInstruction" },
+              { $ref: "#/definitions/schedulableInstructionSubsection" }
             ]
           }
         }
       }
+    }
+  ],
+  definitions: {
+    schedulableInstruction: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/instruction" },
+        { required: ["id", "timing"] }
+      ]
     },
-    storageMethod: {
+    schedulableInstructionSubsection: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/instructionSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              items: { $ref: "#/definitions/schedulableInstruction" }
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+
+// src/schemas/recipe/stacks/attribution/1.schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/stacks/attribution/1.schema.json",
+  title: "Soustack Recipe Stack: attribution v1",
+  description: "Schema for the attribution stack. Ensures namespace data is present when the stack is enabled and vice versa.",
+  type: "object",
+  properties: {
+    stacks: {
       type: "object",
-      required: ["duration"],
-      properties: {
-        duration: { type: "string", pattern: "^P" },
-        method: { type: "string" },
-        notes: { type: "string" }
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
       }
     },
-    substitution: {
+    attribution: {
       type: "object",
-      required: ["ingredient"],
       properties: {
-        ingredient: { type: "string" },
-        critical: { type: "boolean" },
-        notes: { type: "string" },
-        alternatives: {
-          type: "array",
-          items: {
+        url: { type: "string" },
+        author: { type: "string" },
+        datePublished: { type: "string" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          stacks: {
             type: "object",
-            required: ["name", "ratio"],
             properties: {
-              name: { type: "string" },
-              ratio: { type: "string" },
-              notes: { type: "string" },
-              impact: { type: "string" },
-              dietary: {
-                type: "array",
-                items: { type: "string" }
-              }
-            }
+              attribution: { const: 1 }
+            },
+            required: ["attribution"]
+          }
+        }
+      },
+      then: {
+        required: ["attribution"]
+      }
+    },
+    {
+      if: {
+        required: ["attribution"]
+      },
+      then: {
+        required: ["stacks"],
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              attribution: { const: 1 }
+            },
+            required: ["attribution"]
           }
         }
       }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/base.schema.json
-var base_schema_default = {
+// src/schemas/recipe/stacks/media/1.schema.json
+var schema_default2 = {
   $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.",
+  $id: "https://soustack.org/schemas/recipe/stacks/media/1.schema.json",
+  title: "Soustack Recipe Stack: media v1",
+  description: "Schema for the media stack. Guards media blocks based on stack activation and ensures declarations accompany payloads.",
+  type: "object",
+  properties: {
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    media: {
+      type: "object",
+      properties: {
+        images: { type: "array", items: { type: "string" } },
+        videos: { type: "array", items: { type: "string" } }
+      },
+      additionalProperties: false
+    }
+  },
   allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" }
-  ]
+    {
+      if: {
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              media: { const: 1 }
+            },
+            required: ["media"]
+          }
+        }
+      },
+      then: {
+        required: ["media"]
+      }
+    },
+    {
+      if: {
+        required: ["media"]
+      },
+      then: {
+        required: ["stacks"],
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              media: { const: 1 }
+            },
+            required: ["media"]
+          }
+        }
+      }
+    }
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/cookable.schema.json
-var cookable_schema_default = {
+// src/schemas/recipe/stacks/nutrition/1.schema.json
+var schema_default3 = {
   $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.",
+  $id: "https://soustack.org/schemas/recipe/stacks/nutrition/1.schema.json",
+  title: "Soustack Recipe Stack: nutrition v1",
+  description: "Schema for the nutrition stack. Keeps nutrition data aligned with stack declarations and vice versa.",
+  type: "object",
+  properties: {
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    nutrition: {
+      type: "object",
+      properties: {
+        calories: { type: "number" },
+        protein_g: { type: "number" }
+      },
+      additionalProperties: false
+    }
+  },
   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 }
+      if: {
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              nutrition: { const: 1 }
+            },
+            required: ["nutrition"]
+          }
+        }
+      },
+      then: {
+        required: ["nutrition"]
+      }
+    },
+    {
+      if: {
+        required: ["nutrition"]
+      },
+      then: {
+        required: ["stacks"],
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              nutrition: { const: 1 }
+            },
+            required: ["nutrition"]
+          }
+        }
       }
     }
-  ]
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/quantified.schema.json
-var quantified_schema_default = {
+// src/schemas/recipe/stacks/schedule/1.schema.json
+var schema_default4 = {
   $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.",
+  $id: "https://soustack.org/schemas/recipe/stacks/schedule/1.schema.json",
+  title: "Soustack Recipe Stack: schedule v1",
+  description: "Schema for the schedule stack. Enforces bidirectional stack gating and restricts usage to the core profile.",
+  type: "object",
+  properties: {
+    profile: { type: "string" },
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    schedule: {
+      type: "object",
+      properties: {
+        tasks: { type: "array" }
+      },
+      additionalProperties: false
+    }
+  },
   allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" },
     {
-      properties: {
-        ingredients: {
-          type: "array",
-          items: {
-            anyOf: [
-              { $ref: "#/definitions/quantifiedIngredient" },
-              { $ref: "#/definitions/quantifiedIngredientSubsection" }
-            ]
+      if: {
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              schedule: { const: 1 }
+            },
+            required: ["schedule"]
           }
         }
+      },
+      then: {
+        required: ["schedule", "profile"],
+        properties: {
+          profile: { const: "core" }
+        }
       }
-    }
-  ],
-  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: {
+        required: ["schedule"]
+      },
+      then: {
+        required: ["stacks", "profile"],
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              schedule: { const: 1 }
+            },
+            required: ["schedule"]
+          },
+          profile: { const: "core" }
         }
-      ]
+      }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/illustrated.schema.json
-var illustrated_schema_default = {
+// src/schemas/recipe/stacks/taxonomy/1.schema.json
+var schema_default5 = {
   $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.",
+  $id: "https://soustack.org/schemas/recipe/stacks/taxonomy/1.schema.json",
+  title: "Soustack Recipe Stack: taxonomy v1",
+  description: "Schema for the taxonomy stack. Enforces keyword and categorization data when enabled and ensures stack declaration accompanies the namespace block.",
+  type: "object",
+  properties: {
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    taxonomy: {
+      type: "object",
+      properties: {
+        keywords: { type: "array", items: { type: "string" } },
+        category: { type: "string" },
+        cuisine: { type: "string" }
+      },
+      additionalProperties: false
+    }
+  },
   allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" },
     {
-      anyOf: [
-        { required: ["image"] },
-        {
-          properties: {
-            instructions: {
-              type: "array",
-              contains: {
-                anyOf: [
-                  { $ref: "#/definitions/imageInstruction" },
-                  { $ref: "#/definitions/instructionSubsectionWithImage" }
-                ]
-              }
-            }
+      if: {
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              taxonomy: { const: 1 }
+            },
+            required: ["taxonomy"]
           }
         }
-      ]
-    }
-  ],
-  definitions: {
-    imageInstruction: {
-      allOf: [
-        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instruction" },
-        { required: ["image"] }
-      ]
+      },
+      then: {
+        required: ["taxonomy"]
+      }
     },
-    instructionSubsectionWithImage: {
-      allOf: [
-        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instructionSubsection" },
-        {
-          properties: {
-            items: {
-              type: "array",
-              contains: { $ref: "#/definitions/imageInstruction" }
-            }
+    {
+      if: {
+        required: ["taxonomy"]
+      },
+      then: {
+        required: ["stacks"],
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              taxonomy: { const: 1 }
+            },
+            required: ["taxonomy"]
           }
         }
-      ]
+      }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/schedulable.schema.json
-var schedulable_schema_default = {
+// src/schemas/recipe/stacks/times/1.schema.json
+var schema_default6 = {
   $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.",
+  $id: "https://soustack.org/schemas/recipe/stacks/times/1.schema.json",
+  title: "Soustack Recipe Stack: times v1",
+  description: "Schema for the times stack. Maintains alignment between stack declarations and timing payloads.",
+  type: "object",
+  properties: {
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    times: {
+      type: "object",
+      properties: {
+        prepMinutes: { type: "number" },
+        cookMinutes: { type: "number" },
+        totalMinutes: { type: "number" }
+      },
+      additionalProperties: false
+    }
+  },
   allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" },
     {
-      properties: {
-        instructions: {
-          type: "array",
-          items: {
-            anyOf: [
-              { $ref: "#/definitions/schedulableInstruction" },
-              { $ref: "#/definitions/schedulableInstructionSubsection" }
-            ]
+      if: {
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              times: { const: 1 }
+            },
+            required: ["times"]
           }
         }
+      },
+      then: {
+        required: ["times"]
       }
-    }
-  ],
-  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" }
-            }
+    {
+      if: {
+        required: ["times"]
+      },
+      then: {
+        required: ["stacks"],
+        properties: {
+          stacks: {
+            type: "object",
+            properties: {
+              times: { const: 1 }
+            },
+            required: ["times"]
           }
         }
-      ]
+      }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
 // 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 LEGACY_ROOT_SCHEMA_ID = "http://soustack.org/schema/v0.3.0";
+var DEFAULT_ROOT_SCHEMA_ID = "https://soustack.spec/soustack.schema.json";
+var BASE_SCHEMA_ID = "http://soustack.org/schema/recipe/base.schema.json";
+var PROFILE_SCHEMA_PREFIX = "http://soustack.org/schema/recipe/profiles/";
 var validationContexts = /* @__PURE__ */ new Map();
+function loadAllSchemas(ajv) {
+  const schemas = [
+    soustack_schema_default,
+    base_schema_default,
+    minimal_schema_default,
+    core_schema_default,
+    base_schema_default2,
+    cookable_schema_default,
+    illustrated_schema_default,
+    quantified_schema_default,
+    scalable_schema_default,
+    schedulable_schema_default,
+    schema_default,
+    schema_default2,
+    schema_default3,
+    schema_default4,
+    schema_default5,
+    schema_default6
+  ];
+  for (const schema of schemas) {
+    if (schema && typeof schema === "object" && "$id" in schema) {
+      const schemaWithId = schema;
+      if (schemaWithId.$id) {
+        ajv.addSchema(schemaWithId, schemaWithId.$id);
+      }
+    }
+  }
+  ajv.addSchema(
+    {
+      $id: DEFAULT_ROOT_SCHEMA_ID,
+      allOf: [
+        { $ref: LEGACY_ROOT_SCHEMA_ID },
+        {
+          type: "object",
+          properties: {
+            $schema: { const: DEFAULT_ROOT_SCHEMA_ID }
+          }
+        }
+      ]
+    },
+    DEFAULT_ROOT_SCHEMA_ID
+  );
+}
 function createContext(collectAllErrors) {
-  const ajv = new Ajv({ strict: false, allErrors: collectAllErrors });
+  const ajv = new Ajv2020({
+    strict: false,
+    allErrors: collectAllErrors,
+    validateSchema: false
+    // Don't validate schemas themselves
+  });
   addFormats(ajv);
-  const loadedIds = /* @__PURE__ */ new Set();
-  const addSchemaIfNew = (schema) => {
-    if (!schema) return;
-    const schemaId = schema == null ? void 0 : schema.$id;
-    if (schemaId && loadedIds.has(schemaId)) return;
-    ajv.addSchema(schema);
-    if (schemaId) loadedIds.add(schemaId);
+  loadAllSchemas(ajv);
+  const rootValidator = ajv.getSchema(DEFAULT_ROOT_SCHEMA_ID) || ajv.getSchema(LEGACY_ROOT_SCHEMA_ID);
+  const baseValidator = ajv.getSchema(BASE_SCHEMA_ID);
+  return {
+    ajv,
+    rootValidator: rootValidator || void 0,
+    baseValidator: baseValidator || void 0,
+    validators: /* @__PURE__ */ new Map()
   };
-  addSchemaIfNew(schema_default);
-  addSchemaIfNew(soustack_schema_default);
-  Object.values(profileSchemas).forEach(addSchemaIfNew);
-  return { ajv, validators: {} };
 }
 function getContext(collectAllErrors) {
   if (!validationContexts.has(collectAllErrors)) {
@@ -1141,200 +1738,227 @@ function cloneRecipe(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 == null ? void 0 : recipe.time;
-  if (!time || typeof time !== "object" || Array.isArray(time)) return;
-  const structuredKeys = [
-    "prep",
-    "active",
-    "passive",
-    "total"
-  ];
-  structuredKeys.forEach((key) => {
-    const value = time[key];
-    if (typeof value === "number") return;
-    const parsed = parseDuration(value);
-    if (parsed !== null) {
-      time[key] = parsed;
-    }
-  });
-}
-var _a, _b;
-var allowedTopLevelProps = /* @__PURE__ */ new Set([
-  ...Object.keys((_b = (_a = soustack_schema_default) == null ? void 0 : _a.properties) != null ? _b : {}),
-  "metadata",
-  "$schema"
-]);
-function detectUnknownTopLevelKeys(recipe) {
-  if (!recipe || typeof recipe !== "object") return [];
-  const disallowedKeys = Object.keys(recipe).filter(
-    (key) => !allowedTopLevelProps.has(key) && !key.startsWith("x-")
-  );
-  return disallowedKeys.map((key) => ({
-    path: `/${key}`,
-    keyword: "additionalProperties",
-    message: `Unknown top-level property '${key}' is not allowed by the Soustack spec`
-  }));
-}
 function formatAjvError(error) {
-  var _a2;
+  var _a;
   let path = error.instancePath || "/";
-  if (error.keyword === "additionalProperties" && ((_a2 = error.params) == null ? void 0 : _a2.additionalProperty)) {
+  if (error.keyword === "additionalProperties" && ((_a = error.params) == null ? void 0 : _a.additionalProperty)) {
     const extra = error.params.additionalProperty;
     path = `${error.instancePath || ""}/${extra}`.replace(/\/+/g, "/") || "/";
   }
   return {
     path,
     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 != null ? validator : getValidator(profile, context);
-  const isValid = validateFn(data);
-  return !isValid && validateFn.errors ? validateFn.errors.map(formatAjvError) : [];
-}
-function isInstruction(item) {
-  return item && typeof item === "object" && !Array.isArray(item) && "text" in item;
-}
-function isInstructionSubsection(item) {
-  return item && typeof item === "object" && !Array.isArray(item) && "items" in item && "subsection" in item;
-}
-function checkInstructionGraph(recipe) {
-  const instructions = recipe == null ? void 0 : recipe.instructions;
-  if (!Array.isArray(instructions)) return [];
-  const instructionIds = /* @__PURE__ */ new Set();
-  const dependencyRefs = [];
-  const collect = (items, basePath) => {
-    items.forEach((item, index) => {
-      const currentPath = `${basePath}/${index}`;
-      if (isInstructionSubsection(item) && Array.isArray(item.items)) {
-        collect(item.items, `${currentPath}/items`);
-        return;
-      }
-      if (isInstruction(item)) {
-        const id = typeof item.id === "string" ? item.id : void 0;
-        if (id) instructionIds.add(id);
-        if (Array.isArray(item.dependsOn)) {
-          item.dependsOn.forEach((depId, depIndex) => {
-            if (typeof depId === "string") {
-              dependencyRefs.push({
-                fromId: id,
-                toId: depId,
-                path: `${currentPath}/dependsOn/${depIndex}`
-              });
-            }
-          });
-        }
+    message: error.message || "Validation error"
+  };
+}
+function isSoustackSchemaId(schemaId) {
+  return schemaId.startsWith("http://soustack.org/schema") || schemaId.startsWith("https://soustack.org/schema") || schemaId.startsWith("https://soustack.spec/") || schemaId.startsWith("https://soustack.org/schemas/");
+}
+function inferStacksFromPayload(recipe) {
+  const inferred = {};
+  const payloadToStack = {
+    attribution: "attribution",
+    taxonomy: "taxonomy",
+    media: "media",
+    times: "times",
+    nutrition: "nutrition",
+    schedule: "schedule"
+  };
+  for (const [field, stackName] of Object.entries(payloadToStack)) {
+    if (recipe && typeof recipe === "object" && field in recipe && recipe[field] !== void 0) {
+      inferred[stackName] = 1;
+    }
+  }
+  return inferred;
+}
+function getComposedValidator(profile, stacks, context) {
+  const stackIdentifiers = Object.entries(stacks).map(([name, version]) => `${name}@${version}`).sort();
+  const cacheKey = `${profile}::${stackIdentifiers.join(",")}`;
+  const cached = context.validators.get(cacheKey);
+  if (cached) return cached;
+  const allOf = [{ $ref: BASE_SCHEMA_ID }];
+  if (!context.ajv.getSchema(BASE_SCHEMA_ID)) {
+    throw new Error(`Base schema not loaded: ${BASE_SCHEMA_ID}. Ensure schemas are loaded before creating validators.`);
+  }
+  const profileSchemaId = `${PROFILE_SCHEMA_PREFIX}${profile}.schema.json`;
+  if (!context.ajv.getSchema(profileSchemaId)) {
+    throw new Error(`Profile schema not loaded: ${profileSchemaId}`);
+  }
+  allOf.push({ $ref: profileSchemaId });
+  for (const [name, version] of Object.entries(stacks)) {
+    if (typeof version === "number" && version >= 1) {
+      const stackSchemaId = `https://soustack.org/schemas/recipe/stacks/${name}/${version}.schema.json`;
+      if (!context.ajv.getSchema(stackSchemaId)) {
+        throw new Error(`Stack schema not loaded: ${stackSchemaId}`);
       }
-    });
+      allOf.push({ $ref: stackSchemaId });
+    }
+  }
+  const composedSchema = {
+    $id: `urn:soustack:composed:${cacheKey}`,
+    allOf
   };
-  collect(instructions, "/instructions");
-  const errors = [];
-  dependencyRefs.forEach((ref) => {
-    if (!instructionIds.has(ref.toId)) {
-      errors.push({
-        path: ref.path,
-        message: `Instruction dependency references missing id '${ref.toId}'.`
-      });
+  const validateFn = context.ajv.compile(composedSchema);
+  context.validators.set(cacheKey, validateFn);
+  return validateFn;
+}
+function validateRecipeSchemaNormalized(normalizedInput, inputHasStacks, collectAllErrors, schemaOverride) {
+  const normalized = cloneRecipe(normalizedInput);
+  const context = getContext(collectAllErrors);
+  const schemaId = typeof schemaOverride === "string" ? schemaOverride : typeof normalized.$schema === "string" ? normalized.$schema : void 0;
+  const hasSchemaOverride = typeof schemaOverride === "string";
+  const isSoustackSchema = schemaId ? isSoustackSchemaId(schemaId) : false;
+  if (schemaId && isSoustackSchema) {
+    const schemaValidator = context.ajv.getSchema(schemaId);
+    if (!schemaValidator) {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: "/$schema",
+            message: `Unknown schema: ${schemaId}`
+          }
+        ]
+      };
     }
-  });
-  const adjacency = /* @__PURE__ */ new Map();
-  dependencyRefs.forEach((ref) => {
-    var _a2;
-    if (ref.fromId && instructionIds.has(ref.fromId) && instructionIds.has(ref.toId)) {
-      const list = (_a2 = adjacency.get(ref.fromId)) != null ? _a2 : [];
-      list.push({ toId: ref.toId, path: ref.path });
-      adjacency.set(ref.fromId, list);
+    const schemaInput = cloneRecipe(normalized);
+    if (hasSchemaOverride && "$schema" in schemaInput && schemaInput.$schema !== schemaId) {
+      delete schemaInput.$schema;
     }
-  });
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const detectCycles = (nodeId) => {
-    var _a2;
-    if (visiting.has(nodeId)) return;
-    if (visited.has(nodeId)) return;
-    visiting.add(nodeId);
-    const neighbors = (_a2 = adjacency.get(nodeId)) != null ? _a2 : [];
-    neighbors.forEach((edge) => {
-      if (visiting.has(edge.toId)) {
-        errors.push({
-          path: edge.path,
-          message: `Circular dependency detected involving instruction id '${edge.toId}'.`
-        });
-        return;
+    const isLegacySchema = schemaId.startsWith(LEGACY_ROOT_SCHEMA_ID);
+    const shouldRemoveStacks = (isLegacySchema || schemaId === DEFAULT_ROOT_SCHEMA_ID) && !inputHasStacks;
+    if (isLegacySchema && "@type" in schemaInput) {
+      delete schemaInput["@type"];
+    }
+    if (shouldRemoveStacks && "stacks" in schemaInput) {
+      delete schemaInput.stacks;
+    }
+    const schemaValid = schemaValidator(schemaInput);
+    const schemaErrors = schemaValidator.errors || [];
+    return {
+      ok: !!schemaValid,
+      errors: schemaErrors.map(formatAjvError)
+    };
+  }
+  const hasProfile = normalized.profile && typeof normalized.profile === "string";
+  let declaredStacks = {};
+  if (normalized.stacks && typeof normalized.stacks === "object" && !Array.isArray(normalized.stacks)) {
+    for (const [name, version] of Object.entries(normalized.stacks)) {
+      if (typeof version === "number" && version >= 1) {
+        declaredStacks[name] = version;
       }
-      detectCycles(edge.toId);
-    });
-    visiting.delete(nodeId);
-    visited.add(nodeId);
+    }
+  }
+  const inferredStacks = inferStacksFromPayload(normalized);
+  const allStacks = { ...declaredStacks };
+  for (const [name, version] of Object.entries(inferredStacks)) {
+    if (!allStacks[name] || allStacks[name] < version) {
+      allStacks[name] = version;
+    }
+  }
+  let isValid;
+  let errors = [];
+  const profile = hasProfile ? normalized.profile.toLowerCase() : "core";
+  const profileSchemaId = `${PROFILE_SCHEMA_PREFIX}${profile}.schema.json`;
+  if (!context.ajv.getSchema(profileSchemaId)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: "/profile",
+          message: `Profile schema not loaded: ${profileSchemaId}`
+        }
+      ]
+    };
+  }
+  {
+    const validationCopy = cloneRecipe(normalized);
+    if (!validationCopy.stacks || typeof validationCopy.stacks !== "object" || Array.isArray(validationCopy.stacks)) {
+      validationCopy.stacks = declaredStacks;
+    }
+    if (!validationCopy.profile) {
+      validationCopy.profile = profile;
+    }
+    const validator = getComposedValidator(profile, allStacks, context);
+    isValid = validator(validationCopy);
+    errors = validator.errors || [];
+    if (isValid && context.rootValidator) {
+      const rootCheckCopy = cloneRecipe(normalized);
+      if ("@type" in rootCheckCopy) {
+        delete rootCheckCopy["@type"];
+      }
+      if ("stacks" in rootCheckCopy) {
+        delete rootCheckCopy.stacks;
+      }
+      if ("profile" in rootCheckCopy) {
+        delete rootCheckCopy.profile;
+      }
+      const stackPayloadFields = ["attribution", "taxonomy", "media", "times", "nutrition", "schedule"];
+      for (const field of stackPayloadFields) {
+        if (field in rootCheckCopy) {
+          delete rootCheckCopy[field];
+        }
+      }
+      const rootValid = context.rootValidator(rootCheckCopy);
+      if (!rootValid && context.rootValidator.errors) {
+        const unknownKeyErrors = context.rootValidator.errors.filter(
+          (e) => e.keyword === "additionalProperties" && (e.instancePath === "" || e.instancePath === "/")
+        );
+        const schemaConstErrors = context.rootValidator.errors.filter(
+          (e) => e.keyword === "const" && e.instancePath === "/$schema"
+        );
+        const relevantErrors = [...unknownKeyErrors, ...schemaConstErrors];
+        if (relevantErrors.length > 0) {
+          errors.push(...relevantErrors);
+          isValid = false;
+        }
+      }
+    }
+  }
+  return {
+    ok: isValid,
+    errors: errors.map(formatAjvError)
   };
-  instructionIds.forEach((id) => detectCycles(id));
-  return errors;
 }
 function validateRecipe(input, options = {}) {
-  var _a2, _b2, _c, _d;
-  const collectAllErrors = (_a2 = options.collectAllErrors) != null ? _a2 : true;
-  const context = getContext(collectAllErrors);
-  const schemaRef = (_b2 = options.schema) != null ? _b2 : typeof (input == null ? void 0 : input.$schema) === "string" ? input.$schema : void 0;
-  const profile = (_d = (_c = options.profile) != null ? _c : detectProfileFromSchema(schemaRef)) != null ? _d : "base";
-  const { normalized, warnings } = normalizeRecipe(input);
-  const unknownKeyErrors = detectUnknownTopLevelKeys(normalized);
-  const validationErrors = runAjvValidation(normalized, profile, context, schemaRef);
-  const graphErrors = profile === "schedulable" && validationErrors.length === 0 ? checkInstructionGraph(normalized) : [];
-  const errors = [...unknownKeyErrors, ...validationErrors, ...graphErrors];
+  var _a, _b;
+  const { recipe: normalized, warnings } = normalizeRecipe(input);
+  if (options.profile) {
+    normalized.profile = options.profile;
+  }
+  const inputHasStacks = !!input && typeof input === "object" && !Array.isArray(input) && "stacks" in input;
+  const { ok: schemaOk, errors: schemaErrors } = validateRecipeSchemaNormalized(
+    normalized,
+    inputHasStacks,
+    (_a = options.collectAllErrors) != null ? _a : true,
+    options.schema
+  );
+  const mode = (_b = options.mode) != null ? _b : "full";
+  let conformanceIssues = [];
+  let conformanceOk = true;
+  if (mode === "full") {
+    if (schemaOk) {
+      const conformanceResult = validateConformance(normalized);
+      conformanceIssues = conformanceResult.issues;
+      conformanceOk = conformanceResult.ok;
+    } else {
+      conformanceOk = false;
+    }
+  }
+  const ok = schemaOk && (mode === "schema" ? true : conformanceOk);
+  const normalizedRecipe = ok || options.includeNormalized ? normalized : void 0;
   return {
-    valid: errors.length === 0,
-    errors,
+    ok,
+    schemaErrors,
+    conformanceIssues,
     warnings,
-    normalized: errors.length === 0 ? normalized : void 0
+    normalizedRecipe
   };
 }
 function detectProfiles(recipe) {
-  var _a2;
-  const result = validateRecipe(recipe, { profile: "base", collectAllErrors: false });
-  if (!result.valid) return [];
-  const normalizedRecipe = (_a2 = result.normalized) != null ? _a2 : recipe;
-  const profiles = ["base"];
-  const context = getContext(false);
-  Object.keys(profileSchemas).forEach((profile) => {
-    if (profile === "base") return;
-    if (!profileSchemas[profile]) return;
-    const errors = runAjvValidation(normalizedRecipe, profile, context);
-    if (errors.length === 0) {
-      profiles.push(profile);
-    }
-  });
-  return profiles;
+  const result = validateRecipe(recipe, { collectAllErrors: false });
+  if (!result.ok) return [];
+  return ["core"];
 }
 
 // src/converters/yield.ts
@@ -1377,12 +2001,12 @@ function parseYield(value) {
   return void 0;
 }
 function formatYield(yieldValue) {
-  var _a2;
+  var _a;
   if (!yieldValue) return void 0;
   if (!yieldValue.amount && !yieldValue.unit) {
     return void 0;
   }
-  const amount = (_a2 = yieldValue.amount) != null ? _a2 : "";
+  const amount = (_a = yieldValue.amount) != null ? _a : "";
   const unit = yieldValue.unit ? ` ${yieldValue.unit}` : "";
   return `${amount}${unit}`.trim() || yieldValue.description;
 }
@@ -1423,7 +2047,7 @@ function extractUrl(value) {
 
 // src/fromSchemaOrg.ts
 function fromSchemaOrg(input) {
-  var _a2;
+  var _a;
   const recipeNode = extractRecipeNode(input);
   if (!recipeNode) {
     return null;
@@ -1435,22 +2059,42 @@ function fromSchemaOrg(input) {
   const tags = collectTags(recipeNode.recipeCuisine, recipeNode.keywords);
   const category = extractFirst(recipeNode.recipeCategory);
   const source = convertSource(recipeNode);
-  const nutrition = recipeNode.nutrition && typeof recipeNode.nutrition === "object" ? recipeNode.nutrition : void 0;
-  return {
+  const dateModified = recipeNode.dateModified || void 0;
+  const nutrition = convertNutrition(recipeNode.nutrition);
+  const attribution = convertAttribution(recipeNode);
+  const taxonomy = convertTaxonomy(tags, category, extractFirst(recipeNode.recipeCuisine));
+  const media = convertMedia(recipeNode.image, recipeNode.video);
+  const times = convertTimes(time);
+  const stacks = {};
+  if (attribution) stacks.attribution = 1;
+  if (taxonomy) stacks.taxonomy = 1;
+  if (media) stacks.media = 1;
+  if (nutrition) stacks.nutrition = 1;
+  if (times) stacks.times = 1;
+  const rawRecipe = {
+    "@type": "Recipe",
+    profile: "minimal",
+    stacks,
     name: recipeNode.name.trim(),
-    description: ((_a2 = recipeNode.description) == null ? void 0 : _a2.trim()) || void 0,
+    description: ((_a = recipeNode.description) == null ? void 0 : _a.trim()) || void 0,
     image: normalizeImage(recipeNode.image),
     category,
     tags: tags.length ? tags : void 0,
     source,
     dateAdded: recipeNode.datePublished || void 0,
-    dateModified: recipeNode.dateModified || void 0,
     yield: recipeYield,
     time,
     ingredients,
     instructions,
-    nutrition
+    ...dateModified ? { dateModified } : {},
+    ...nutrition ? { nutrition } : {},
+    ...attribution ? { attribution } : {},
+    ...taxonomy ? { taxonomy } : {},
+    ...media ? { media } : {},
+    ...times ? { times } : {}
   };
+  const { recipe } = normalizeRecipe(rawRecipe);
+  return recipe;
 }
 function extractRecipeNode(input) {
   if (!input) return null;
@@ -1497,7 +2141,7 @@ function convertIngredients(value) {
   return normalized.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean);
 }
 function convertInstructions(value) {
-  var _a2;
+  var _a;
   if (!value) return [];
   const normalized = Array.isArray(value) ? value : [value];
   const result = [];
@@ -1514,7 +2158,7 @@ function convertInstructions(value) {
       const subsectionItems = extractSectionItems(entry.itemListElement);
       if (subsectionItems.length) {
         result.push({
-          subsection: ((_a2 = entry.name) == null ? void 0 : _a2.trim()) || "Section",
+          subsection: ((_a = entry.name) == null ? void 0 : _a.trim()) || "Section",
           items: subsectionItems
         });
       }
@@ -1598,9 +2242,9 @@ function isHowToSection(value) {
   return Boolean(value) && typeof value === "object" && value["@type"] === "HowToSection" && Array.isArray(value.itemListElement);
 }
 function convertTime(recipe) {
-  var _a2, _b2, _c;
-  const prep = smartParseDuration((_a2 = recipe.prepTime) != null ? _a2 : "");
-  const cook = smartParseDuration((_b2 = recipe.cookTime) != null ? _b2 : "");
+  var _a, _b, _c;
+  const prep = smartParseDuration((_a = recipe.prepTime) != null ? _a : "");
+  const cook = smartParseDuration((_b = recipe.cookTime) != null ? _b : "");
   const total = smartParseDuration((_c = recipe.totalTime) != null ? _c : "");
   const structured = {};
   if (prep !== null && prep !== void 0) structured.prep = prep;
@@ -1634,10 +2278,10 @@ function extractFirst(value) {
   return arr.length ? arr[0] : void 0;
 }
 function convertSource(recipe) {
-  var _a2;
+  var _a;
   const author = extractEntityName(recipe.author);
   const publisher = extractEntityName(recipe.publisher);
-  const url = (_a2 = recipe.url || recipe.mainEntityOfPage) == null ? void 0 : _a2.trim();
+  const url = (_a = recipe.url || recipe.mainEntityOfPage) == null ? void 0 : _a.trim();
   const source = {};
   if (author) source.author = author;
   if (publisher) source.name = publisher;
@@ -1665,17 +2309,174 @@ function extractEntityName(value) {
   }
   return void 0;
 }
+function convertAttribution(recipe) {
+  var _a, _b;
+  const attribution = {};
+  const url = (_a = recipe.url || recipe.mainEntityOfPage) == null ? void 0 : _a.trim();
+  const author = extractEntityName(recipe.author);
+  const datePublished = (_b = recipe.datePublished) == null ? void 0 : _b.trim();
+  if (url) attribution.url = url;
+  if (author) attribution.author = author;
+  if (datePublished) attribution.datePublished = datePublished;
+  return Object.keys(attribution).length ? attribution : void 0;
+}
+function convertTaxonomy(keywords, category, cuisine) {
+  const taxonomy = {};
+  if (keywords.length) taxonomy.keywords = keywords;
+  if (category) taxonomy.category = category;
+  if (cuisine) taxonomy.cuisine = cuisine;
+  return Object.keys(taxonomy).length ? taxonomy : void 0;
+}
+function normalizeMediaList(value) {
+  if (!value) return [];
+  if (typeof value === "string") return [value.trim()].filter(Boolean);
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? item.trim() : extractMediaUrl(item)).filter((entry) => Boolean(entry == null ? void 0 : entry.length));
+  }
+  const url = extractMediaUrl(value);
+  return url ? [url] : [];
+}
+function extractMediaUrl(value) {
+  if (value && typeof value === "object" && "url" in value && typeof value.url === "string") {
+    const trimmed = value.url.trim();
+    return trimmed || void 0;
+  }
+  return void 0;
+}
+function convertMedia(image, video) {
+  const normalizedImage = normalizeImage(image);
+  const images = normalizedImage ? Array.isArray(normalizedImage) ? normalizedImage : [normalizedImage] : [];
+  const videos = normalizeMediaList(video);
+  const media = {};
+  if (images.length) media.images = images;
+  if (videos.length) media.videos = videos;
+  return Object.keys(media).length ? media : void 0;
+}
+function convertTimes(time) {
+  if (!time) return void 0;
+  const times = {};
+  if (typeof time.prep === "number") times.prepMinutes = time.prep;
+  if (typeof time.active === "number") times.cookMinutes = time.active;
+  if (typeof time.total === "number") times.totalMinutes = time.total;
+  return Object.keys(times).length ? times : void 0;
+}
+function convertNutrition(nutrition) {
+  if (!nutrition || typeof nutrition !== "object") {
+    return void 0;
+  }
+  const result = {};
+  let hasData = false;
+  if ("calories" in nutrition) {
+    const calories = nutrition.calories;
+    if (typeof calories === "number") {
+      result.calories = calories;
+      hasData = true;
+    } else if (typeof calories === "string") {
+      const parsed = parseFloat(calories.replace(/[^\d.-]/g, ""));
+      if (!isNaN(parsed)) {
+        result.calories = parsed;
+        hasData = true;
+      }
+    }
+  }
+  if ("proteinContent" in nutrition || "protein_g" in nutrition) {
+    const protein = nutrition.proteinContent || nutrition.protein_g;
+    if (typeof protein === "number") {
+      result.protein_g = protein;
+      hasData = true;
+    } else if (typeof protein === "string") {
+      const parsed = parseFloat(protein.replace(/[^\d.-]/g, ""));
+      if (!isNaN(parsed)) {
+        result.protein_g = parsed;
+        hasData = true;
+      }
+    }
+  }
+  return hasData ? result : void 0;
+}
+
+// src/schemas/registry/stacks.json
+var stacks_default = {
+  stacks: [
+    {
+      id: "attribution",
+      versions: [1],
+      latest: 1,
+      namespace: "http://soustack.org/schema/v0.3.0/stacks/attribution",
+      schema: "http://soustack.org/schema/v0.3.0/stacks/attribution",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "taxonomy",
+      versions: [1],
+      latest: 1,
+      namespace: "http://soustack.org/schema/v0.3.0/stacks/taxonomy",
+      schema: "http://soustack.org/schema/v0.3.0/stacks/taxonomy",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "high",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "media",
+      versions: [1],
+      latest: 1,
+      namespace: "http://soustack.org/schema/v0.3.0/stacks/media",
+      schema: "http://soustack.org/schema/v0.3.0/stacks/media",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "nutrition",
+      versions: [1],
+      latest: 1,
+      namespace: "http://soustack.org/schema/v0.3.0/stacks/nutrition",
+      schema: "http://soustack.org/schema/v0.3.0/stacks/nutrition",
+      schemaOrgMappable: false,
+      schemaOrgConfidence: "low",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "times",
+      versions: [1],
+      latest: 1,
+      namespace: "http://soustack.org/schema/v0.3.0/stacks/times",
+      schema: "http://soustack.org/schema/v0.3.0/stacks/times",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "schedule",
+      versions: [1],
+      latest: 1,
+      namespace: "http://soustack.org/schema/v0.3.0/stacks/schedule",
+      schema: "http://soustack.org/schema/v0.3.0/stacks/schedule",
+      schemaOrgMappable: false,
+      schemaOrgConfidence: "low",
+      minProfile: "core",
+      allowedOnMinimal: false
+    }
+  ]
+};
 
 // src/converters/toSchemaOrg.ts
 function convertBasicMetadata(recipe) {
-  var _a2;
+  var _a;
   return cleanOutput({
     "@context": "https://schema.org",
     "@type": "Recipe",
     name: recipe.name,
     description: recipe.description,
     image: recipe.image,
-    url: (_a2 = recipe.source) == null ? void 0 : _a2.url,
+    url: (_a = recipe.source) == null ? void 0 : _a.url,
     datePublished: recipe.dateAdded,
     dateModified: recipe.dateModified
   });
@@ -1683,7 +2484,7 @@ function convertBasicMetadata(recipe) {
 function convertIngredients2(ingredients = []) {
   const result = [];
   ingredients.forEach((ingredient) => {
-    var _a2;
+    var _a;
     if (!ingredient) {
       return;
     }
@@ -1713,7 +2514,7 @@ function convertIngredients2(ingredients = []) {
       });
       return;
     }
-    const value = (_a2 = ingredient.item) == null ? void 0 : _a2.trim();
+    const value = (_a = ingredient.item) == null ? void 0 : _a.trim();
     if (value) {
       result.push(value);
     }
@@ -1748,13 +2549,13 @@ function convertInstruction(entry) {
   return createHowToStep(String(entry));
 }
 function createHowToStep(entry) {
-  var _a2;
+  var _a;
   if (!entry) return null;
   if (typeof entry === "string") {
     const trimmed2 = entry.trim();
     return trimmed2 || null;
   }
-  const trimmed = (_a2 = entry.text) == null ? void 0 : _a2.trim();
+  const trimmed = (_a = entry.text) == null ? void 0 : _a.trim();
   if (!trimmed) {
     return null;
   }
@@ -1806,6 +2607,22 @@ function convertTime2(time) {
   }
   return result;
 }
+function convertTimesModule(times) {
+  if (!times) {
+    return {};
+  }
+  const result = {};
+  if (times.prepMinutes !== void 0) {
+    result.prepTime = formatDuration(times.prepMinutes);
+  }
+  if (times.cookMinutes !== void 0) {
+    result.cookTime = formatDuration(times.cookMinutes);
+  }
+  if (times.totalMinutes !== void 0) {
+    result.totalTime = formatDuration(times.totalMinutes);
+  }
+  return result;
+}
 function convertYield(yld) {
   if (!yld) {
     return void 0;
@@ -1844,33 +2661,65 @@ function convertCategoryTags(category, tags) {
   }
   return result;
 }
-function convertNutrition(nutrition) {
+function convertNutrition2(nutrition) {
   if (!nutrition) {
     return void 0;
   }
-  return {
-    ...nutrition,
+  const result = {
     "@type": "NutritionInformation"
   };
+  if (nutrition.calories !== void 0) {
+    if (typeof nutrition.calories === "number") {
+      result.calories = `${nutrition.calories} calories`;
+    } else {
+      result.calories = nutrition.calories;
+    }
+  }
+  Object.keys(nutrition).forEach((key) => {
+    if (key !== "calories" && key !== "@type") {
+      result[key] = nutrition[key];
+    }
+  });
+  return result;
 }
 function cleanOutput(obj) {
   return Object.fromEntries(
     Object.entries(obj).filter(([, value]) => value !== void 0)
   );
 }
+function getSchemaOrgMappableStacks(stacks = {}) {
+  const mappableStackIds = /* @__PURE__ */ new Set();
+  const mappableFromRegistry = stacks_default.stacks.filter((stack) => stack.schemaOrgMappable).map((stack) => `${stack.id}@${stack.latest}`);
+  for (const [name, version] of Object.entries(stacks)) {
+    const stackId = `${name}@${version}`;
+    if (mappableFromRegistry.includes(stackId)) {
+      mappableStackIds.add(stackId);
+    }
+  }
+  return mappableStackIds;
+}
 function toSchemaOrg(recipe) {
   const base = convertBasicMetadata(recipe);
   const ingredients = convertIngredients2(recipe.ingredients);
   const instructions = convertInstructions2(recipe.instructions);
-  const nutrition = convertNutrition(recipe.nutrition);
+  const recipeStacks = recipe.stacks && typeof recipe.stacks === "object" && !Array.isArray(recipe.stacks) ? recipe.stacks : {};
+  const mappableStacks = getSchemaOrgMappableStacks(recipeStacks);
+  const hasMappableNutrition = mappableStacks.has("nutrition@1");
+  const nutrition = hasMappableNutrition ? convertNutrition2(recipe.nutrition) : void 0;
+  const hasMappableTimes = mappableStacks.has("times@1");
+  const timeData = hasMappableTimes ? recipe.times ? convertTimesModule(recipe.times) : convertTime2(recipe.time) : {};
+  const hasMappableAttribution = mappableStacks.has("attribution@1");
+  const attributionData = hasMappableAttribution ? convertAuthor(recipe.source) : {};
+  const hasMappableTaxonomy = mappableStacks.has("taxonomy@1");
+  const taxonomyData = hasMappableTaxonomy ? convertCategoryTags(recipe.category, recipe.tags) : {};
   return cleanOutput({
     ...base,
     recipeIngredient: ingredients.length ? ingredients : void 0,
     recipeInstructions: instructions.length ? instructions : void 0,
     recipeYield: convertYield(recipe.yield),
-    ...convertTime2(recipe.time),
-    ...convertAuthor(recipe.source),
-    ...convertCategoryTags(recipe.category, recipe.tags),
+    ...timeData,
+    ...attributionData,
+    ...taxonomyData,
     nutrition
   });
 }
@@ -1889,8 +2738,6 @@ function isRecipeNode(value) {
     return false;
   }
   const type = value["@type"];
-  fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/utils.ts:14", message: "isRecipeNode check", data: { type, typeLower: typeof type === "string" ? type.toLowerCase() : Array.isArray(type) ? type.map((t) => typeof t === "string" ? t.toLowerCase() : t) : void 0, isMatch: typeof type === "string" ? RECIPE_TYPES.has(type.toLowerCase()) : Array.isArray(type) ? type.some((e) => typeof e === "string" && RECIPE_TYPES.has(e.toLowerCase())) : false }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
-  });
   if (typeof type === "string") {
     return RECIPE_TYPES.has(type.toLowerCase());
   }
@@ -1928,7 +2775,7 @@ function extractRecipeBrowser(html) {
   return { recipe: null, source: null };
 }
 function extractJsonLdBrowser(html) {
-  var _a2;
+  var _a;
   if (typeof globalThis.DOMParser === "undefined") {
     return null;
   }
@@ -1943,7 +2790,7 @@ function extractJsonLdBrowser(html) {
     if (!parsed) return;
     collectCandidates(parsed, candidates);
   });
-  return (_a2 = candidates[0]) != null ? _a2 : null;
+  return (_a = candidates[0]) != null ? _a : null;
 }
 function extractMicrodataBrowser(html) {
   if (typeof globalThis.DOMParser === "undefined") {
@@ -1976,8 +2823,8 @@ function extractMicrodataBrowser(html) {
   }
   const instructions = [];
   recipeEl.querySelectorAll('[itemprop="recipeInstructions"]').forEach((el) => {
-    var _a2;
-    const text = normalizeText(el.getAttribute("content")) || normalizeText(((_a2 = el.querySelector('[itemprop="text"]')) == null ? void 0 : _a2.textContent) || void 0) || normalizeText(el.textContent || void 0);
+    var _a;
+    const text = normalizeText(el.getAttribute("content")) || normalizeText(((_a = el.querySelector('[itemprop="text"]')) == null ? void 0 : _a.textContent) || void 0) || normalizeText(el.textContent || void 0);
     if (text) instructions.push(text);
   });
   if (instructions.length) {
@@ -2019,8 +2866,521 @@ function extractSchemaOrgRecipeFromHTML(html) {
 }
 
 // src/specVersion.ts
-var SOUSTACK_SPEC_VERSION = "0.2.1";
+var SOUSTACK_SPEC_VERSION = "0.3.0";
+
+// src/conversion/units.ts
+var MASS_UNITS = {
+  g: {
+    dimension: "mass",
+    toMetricBase: 1,
+    metricBaseUnit: "g",
+    isMetric: true
+  },
+  kg: {
+    dimension: "mass",
+    toMetricBase: 1e3,
+    metricBaseUnit: "g",
+    isMetric: true
+  },
+  oz: {
+    dimension: "mass",
+    toMetricBase: 28.349523125,
+    metricBaseUnit: "g",
+    isMetric: false
+  },
+  lb: {
+    dimension: "mass",
+    toMetricBase: 453.59237,
+    metricBaseUnit: "g",
+    isMetric: false
+  }
+};
+var VOLUME_UNITS = {
+  ml: {
+    dimension: "volume",
+    toMetricBase: 1,
+    metricBaseUnit: "ml",
+    isMetric: true
+  },
+  l: {
+    dimension: "volume",
+    toMetricBase: 1e3,
+    metricBaseUnit: "ml",
+    isMetric: true
+  },
+  tsp: {
+    dimension: "volume",
+    toMetricBase: 4.92892159375,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  tbsp: {
+    dimension: "volume",
+    toMetricBase: 14.78676478125,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  fl_oz: {
+    dimension: "volume",
+    toMetricBase: 29.5735295625,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  cup: {
+    dimension: "volume",
+    toMetricBase: 236.5882365,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  pint: {
+    dimension: "volume",
+    toMetricBase: 473.176473,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  quart: {
+    dimension: "volume",
+    toMetricBase: 946.352946,
+    metricBaseUnit: "ml",
+    isMetric: false
+  },
+  gallon: {
+    dimension: "volume",
+    toMetricBase: 3785.411784,
+    metricBaseUnit: "ml",
+    isMetric: false
+  }
+};
+var COUNT_UNITS = {
+  clove: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  sprig: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  leaf: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  pinch: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  bottle: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  },
+  count: {
+    dimension: "count",
+    toMetricBase: 1,
+    metricBaseUnit: "count",
+    isMetric: true
+  }
+};
+var UNIT_DEFINITIONS = {
+  ...MASS_UNITS,
+  ...VOLUME_UNITS,
+  ...COUNT_UNITS
+};
+function normalizeUnitToken(unit) {
+  var _a;
+  if (!unit) {
+    return null;
+  }
+  const token = unit.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  const canonical = (_a = UNIT_SYNONYMS[token]) != null ? _a : token;
+  return canonical in UNIT_DEFINITIONS ? canonical : null;
+}
+var UNIT_SYNONYMS = {
+  teaspoons: "tsp",
+  teaspoon: "tsp",
+  tsps: "tsp",
+  tbsp: "tbsp",
+  tbsps: "tbsp",
+  tablespoon: "tbsp",
+  tablespoons: "tbsp",
+  cup: "cup",
+  cups: "cup",
+  pint: "pint",
+  pints: "pint",
+  quart: "quart",
+  quarts: "quart",
+  gallon: "gallon",
+  gallons: "gallon",
+  ml: "ml",
+  milliliter: "ml",
+  milliliters: "ml",
+  millilitre: "ml",
+  millilitres: "ml",
+  l: "l",
+  liter: "l",
+  liters: "l",
+  litre: "l",
+  litres: "l",
+  fl_oz: "fl_oz",
+  "fl.oz": "fl_oz",
+  "fl.oz.": "fl_oz",
+  "fl_oz.": "fl_oz",
+  "fl oz": "fl_oz",
+  "fl oz.": "fl_oz",
+  fluid_ounce: "fl_oz",
+  fluid_ounces: "fl_oz",
+  oz: "oz",
+  ounce: "oz",
+  ounces: "oz",
+  lb: "lb",
+  lbs: "lb",
+  pound: "lb",
+  pounds: "lb",
+  g: "g",
+  gram: "g",
+  grams: "g",
+  kg: "kg",
+  kilogram: "kg",
+  kilograms: "kg",
+  clove: "clove",
+  cloves: "clove",
+  sprig: "sprig",
+  sprigs: "sprig",
+  leaf: "leaf",
+  leaves: "leaf",
+  pinch: "pinch",
+  pinches: "pinch",
+  bottle: "bottle",
+  bottles: "bottle",
+  count: "count",
+  counts: "count"
+};
+function convertToMetricBase(quantity, unit) {
+  const definition = UNIT_DEFINITIONS[unit];
+  const quantityInMetricBase = quantity * definition.toMetricBase;
+  return {
+    quantity: quantityInMetricBase,
+    baseUnit: definition.metricBaseUnit,
+    definition
+  };
+}
+
+// src/conversion/convertLineItem.ts
+var UnknownUnitError = class extends Error {
+  constructor(unit) {
+    super(`Unknown unit "${unit}".`);
+    this.unit = unit;
+    this.name = "UnknownUnitError";
+  }
+};
+var UnsupportedConversionError = class extends Error {
+  constructor(unit, mode) {
+    super(`Cannot convert unit "${unit}" in ${mode} mode.`);
+    this.unit = unit;
+    this.mode = mode;
+    this.name = "UnsupportedConversionError";
+  }
+};
+var MissingEquivalencyError = class extends Error {
+  constructor(ingredient, unit) {
+    super(
+      `No volume to mass equivalency for "${ingredient}" (${unit}).`
+    );
+    this.ingredient = ingredient;
+    this.unit = unit;
+    this.name = "MissingEquivalencyError";
+  }
+};
+var VOLUME_TO_MASS_EQUIV_G_PER_UNIT = {
+  flour: {
+    cup: 120
+  }
+};
+var DEFAULT_ROUND_MODE = "sane";
+function convertLineItemToMetric(item, mode, opts) {
+  var _a, _b, _c, _d;
+  const roundMode = (_a = opts == null ? void 0 : opts.round) != null ? _a : DEFAULT_ROUND_MODE;
+  const normalizedUnit = normalizeUnitToken(item.unit);
+  if (!normalizedUnit) {
+    if (!item.unit || item.unit.trim() === "") {
+      return item;
+    }
+    throw new UnknownUnitError(item.unit);
+  }
+  const definition = UNIT_DEFINITIONS[normalizedUnit];
+  if (definition.dimension === "count") {
+    return item;
+  }
+  if (mode === "volume") {
+    if (definition.dimension !== "volume") {
+      throw new UnsupportedConversionError((_b = item.unit) != null ? _b : "", mode);
+    }
+    const { quantity, unit } = finalizeMetricVolume(
+      convertToMetricBase(item.quantity, normalizedUnit).quantity,
+      roundMode
+    );
+    return {
+      ...item,
+      quantity,
+      unit
+    };
+  }
+  if (definition.dimension === "mass") {
+    const { quantity, unit } = finalizeMetricMass(
+      convertToMetricBase(item.quantity, normalizedUnit).quantity,
+      roundMode
+    );
+    return {
+      ...item,
+      quantity,
+      unit
+    };
+  }
+  if (definition.dimension !== "volume") {
+    throw new UnsupportedConversionError((_c = item.unit) != null ? _c : "", mode);
+  }
+  const gramsPerUnit = lookupEquivalency(
+    item.ingredient,
+    normalizedUnit
+  );
+  if (!gramsPerUnit) {
+    throw new MissingEquivalencyError(item.ingredient, (_d = item.unit) != null ? _d : "");
+  }
+  const grams = item.quantity * gramsPerUnit;
+  const massResult = finalizeMetricMass(grams, roundMode);
+  return {
+    ...item,
+    quantity: massResult.quantity,
+    unit: massResult.unit,
+    notes: `Converted using ${gramsPerUnit}g per ${normalizedUnit} for ${item.ingredient}.`
+  };
+}
+function finalizeMetricVolume(milliliters, roundMode) {
+  if (roundMode === "none") {
+    return milliliters >= 1e3 ? { quantity: milliliters / 1e3, unit: "l" } : { quantity: milliliters, unit: "ml" };
+  }
+  const roundedMl = roundMilliliters(milliliters);
+  if (roundedMl >= 1e3) {
+    const liters = roundedMl / 1e3;
+    return {
+      quantity: roundLargeMetric(liters),
+      unit: "l"
+    };
+  }
+  return { quantity: roundedMl, unit: "ml" };
+}
+function finalizeMetricMass(grams, roundMode) {
+  if (roundMode === "none") {
+    return grams >= 1e3 ? { quantity: grams / 1e3, unit: "kg" } : { quantity: grams, unit: "g" };
+  }
+  const roundedGrams = roundGrams(grams);
+  if (roundedGrams >= 1e3) {
+    const kilograms = roundedGrams / 1e3;
+    return {
+      quantity: roundLargeMetric(kilograms),
+      unit: "kg"
+    };
+  }
+  return { quantity: roundedGrams, unit: "g" };
+}
+function roundGrams(value) {
+  if (value < 1e3) {
+    return Math.round(value);
+  }
+  return Math.round(value / 5) * 5;
+}
+function roundMilliliters(value) {
+  if (value < 1e3) {
+    return Math.round(value);
+  }
+  return Math.round(value / 10) * 10;
+}
+function roundLargeMetric(value) {
+  return Math.round(value * 100) / 100;
+}
+function lookupEquivalency(ingredient, unit) {
+  var _a;
+  const key = ingredient.trim().toLowerCase();
+  return (_a = VOLUME_TO_MASS_EQUIV_G_PER_UNIT[key]) == null ? void 0 : _a[unit];
+}
+
+// src/mise-en-place/index.ts
+function miseEnPlace(ingredients) {
+  const list = Array.isArray(ingredients) ? ingredients : [];
+  const prepGroups = /* @__PURE__ */ new Map();
+  const stateGroups = /* @__PURE__ */ new Map();
+  let measureTask;
+  let otherTask;
+  const ungrouped = [];
+  for (const ingredient of list) {
+    if (!ingredient || typeof ingredient !== "object") continue;
+    const label = deriveIngredientLabel(ingredient);
+    const quantity = normalizeQuantity(ingredient.quantity);
+    const baseNotes = toDisplayString(ingredient.notes);
+    const prepNotes = toDisplayString(ingredient.prep);
+    const isOptional = typeof ingredient.optional === "boolean" ? ingredient.optional : void 0;
+    const buildItem = (extraNotes) => {
+      const item = {
+        ingredient: label
+      };
+      if (quantity) {
+        item.quantity = { ...quantity };
+      }
+      if (typeof isOptional === "boolean") {
+        item.optional = isOptional;
+      }
+      const notes = combineNotes(extraNotes, baseNotes);
+      if (notes) {
+        item.notes = notes;
+      }
+      return item;
+    };
+    let addedToTask = false;
+    let hasPrepGrouping = false;
+    const prepActionKeys = extractNormalizedList(ingredient.prepActions);
+    if (prepActionKeys.length > 0) {
+      hasPrepGrouping = true;
+      for (const actionKey of prepActionKeys) {
+        const task = ensureGroup(prepGroups, actionKey, () => ({
+          category: "prep",
+          action: actionKey,
+          items: []
+        }));
+        task.items.push(buildItem());
+        addedToTask = true;
+      }
+    } else {
+      const singleActionKey = normalizeKey(ingredient.prepAction);
+      if (singleActionKey) {
+        hasPrepGrouping = true;
+        const task = ensureGroup(prepGroups, singleActionKey, () => ({
+          category: "prep",
+          action: singleActionKey,
+          items: []
+        }));
+        task.items.push(buildItem());
+        addedToTask = true;
+      } else if (prepNotes) {
+        otherTask = otherTask != null ? otherTask : { category: "other", items: [] };
+        otherTask.items.push(buildItem(prepNotes));
+        addedToTask = true;
+      }
+    }
+    const formKey = normalizeKey(ingredient.form);
+    const hasStateGrouping = Boolean(formKey);
+    if (formKey) {
+      const task = ensureGroup(stateGroups, formKey, () => ({
+        category: "state",
+        form: formKey,
+        items: []
+      }));
+      task.items.push(buildItem());
+      addedToTask = true;
+    }
+    const shouldMeasure = Boolean(quantity) && !hasPrepGrouping && !hasStateGrouping;
+    if (shouldMeasure) {
+      measureTask = measureTask != null ? measureTask : { category: "measure", items: [] };
+      measureTask.items.push(buildItem());
+      addedToTask = true;
+    }
+    if (!addedToTask) {
+      ungrouped.push(ingredient);
+    }
+  }
+  const tasks = [
+    ...Array.from(prepGroups.values()).sort((a, b) => localeCompare(a.action, b.action)),
+    ...Array.from(stateGroups.values()).sort((a, b) => localeCompare(a.form, b.form))
+  ];
+  if (measureTask) {
+    tasks.push(measureTask);
+  }
+  if (otherTask) {
+    tasks.push(otherTask);
+  }
+  return { tasks, ungrouped };
+}
+function deriveIngredientLabel(ingredient) {
+  var _a, _b, _c;
+  return (_c = (_b = (_a = toDisplayString(ingredient.name)) != null ? _a : toDisplayString(ingredient.item)) != null ? _b : toDisplayString(ingredient.id)) != null ? _c : "ingredient";
+}
+function extractNormalizedList(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const key = normalizeKey(value);
+    if (key && !seen.has(key)) {
+      seen.add(key);
+      result.push(key);
+    }
+  }
+  return result;
+}
+function normalizeKey(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim().toLowerCase();
+  return trimmed || null;
+}
+function toDisplayString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function combineNotes(...notes) {
+  const cleaned = notes.map((note) => toDisplayString(note != null ? note : void 0)).filter(Boolean);
+  if (cleaned.length === 0) {
+    return void 0;
+  }
+  return cleaned.join(" | ");
+}
+function normalizeQuantity(quantity) {
+  if (!quantity || typeof quantity !== "object") {
+    return void 0;
+  }
+  const amount = quantity.amount;
+  if (typeof amount !== "number" || Number.isNaN(amount)) {
+    return void 0;
+  }
+  const normalized = { amount };
+  if ("unit" in quantity) {
+    const unit = quantity.unit;
+    if (typeof unit === "string") {
+      const trimmed = unit.trim();
+      if (trimmed) {
+        normalized.unit = trimmed;
+      }
+    } else if (unit === null) {
+      normalized.unit = null;
+    }
+  }
+  return normalized;
+}
+function ensureGroup(map, key, factory) {
+  let task = map.get(key);
+  if (!task) {
+    task = factory();
+    map.set(key, task);
+  }
+  return task;
+}
+function localeCompare(left, right) {
+  return (left != null ? left : "").localeCompare(right != null ? right : "");
+}
 
-export { SOUSTACK_SPEC_VERSION, detectProfiles, extractSchemaOrgRecipeFromHTML, fromSchemaOrg, scaleRecipe, toSchemaOrg, validateRecipe };
+export { MissingEquivalencyError, SOUSTACK_SPEC_VERSION, UnknownUnitError, UnsupportedConversionError, convertLineItemToMetric, detectProfiles, extractSchemaOrgRecipeFromHTML, fromSchemaOrg, miseEnPlace, normalizeRecipe, scaleRecipe, toSchemaOrg, validateRecipe };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map