soustack 0.2.3 → 0.3.0

package/dist/cli/index.js

@@ -364,8 +364,22 @@ function fromSchemaOrg(input) {
   const tags = collectTags(recipeNode.recipeCuisine, recipeNode.keywords);
   const category = extractFirst(recipeNode.recipeCategory);
   const source = convertSource(recipeNode);
-  const nutrition = recipeNode.nutrition && typeof recipeNode.nutrition === "object" ? recipeNode.nutrition : void 0;
+  const dateModified = recipeNode.dateModified || void 0;
+  const nutrition = convertNutrition(recipeNode.nutrition);
+  const attribution = convertAttribution(recipeNode);
+  const taxonomy = convertTaxonomy(tags, category, extractFirst(recipeNode.recipeCuisine));
+  const media = convertMedia(recipeNode.image, recipeNode.video);
+  const times = convertTimes(time);
+  const modules = [];
+  if (attribution) modules.push("attribution@1");
+  if (taxonomy) modules.push("taxonomy@1");
+  if (media) modules.push("media@1");
+  if (nutrition) modules.push("nutrition@1");
+  if (times) modules.push("times@1");
   return {
+    "@type": "Recipe",
+    profile: "minimal",
+    modules: modules.sort(),
     name: recipeNode.name.trim(),
     description: recipeNode.description?.trim() || void 0,
     image: normalizeImage(recipeNode.image),
@@ -373,12 +387,16 @@ function fromSchemaOrg(input) {
     tags: tags.length ? tags : void 0,
     source,
     dateAdded: recipeNode.datePublished || void 0,
-    dateModified: recipeNode.dateModified || void 0,
     yield: recipeYield,
     time,
     ingredients,
     instructions,
-    nutrition
+    ...dateModified ? { dateModified } : {},
+    ...nutrition ? { nutrition } : {},
+    ...attribution ? { attribution } : {},
+    ...taxonomy ? { taxonomy } : {},
+    ...media ? { media } : {},
+    ...times ? { times } : {}
   };
 }
 function extractRecipeNode(input) {
@@ -591,6 +609,174 @@ function extractEntityName(value) {
   }
   return void 0;
 }
+function convertAttribution(recipe) {
+  const attribution = {};
+  const url = (recipe.url || recipe.mainEntityOfPage)?.trim();
+  const author = extractEntityName(recipe.author);
+  const datePublished = recipe.datePublished?.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?.length));
+  }
+  const url = extractMediaUrl(value);
+  return url ? [url] : [];
+}
+function extractMediaUrl(value) {
+  if (value && typeof value === "object" && "url" in value && typeof value.url === "string") {
+    const trimmed = value.url.trim();
+    return trimmed || void 0;
+  }
+  return void 0;
+}
+function convertMedia(image, video) {
+  const normalizedImage = normalizeImage(image);
+  const images = normalizedImage ? Array.isArray(normalizedImage) ? normalizedImage : [normalizedImage] : [];
+  const videos = normalizeMediaList(video);
+  const media = {};
+  if (images.length) media.images = images;
+  if (videos.length) media.videos = videos;
+  return Object.keys(media).length ? media : void 0;
+}
+function convertTimes(time) {
+  if (!time) return void 0;
+  const times = {};
+  if (typeof time.prep === "number") times.prepMinutes = time.prep;
+  if (typeof time.active === "number") times.cookMinutes = time.active;
+  if (typeof time.total === "number") times.totalMinutes = time.total;
+  return Object.keys(times).length ? times : void 0;
+}
+function convertNutrition(nutrition) {
+  if (!nutrition || typeof nutrition !== "object") {
+    return void 0;
+  }
+  const result = {};
+  let hasData = false;
+  if ("calories" in nutrition) {
+    const calories = nutrition.calories;
+    if (typeof calories === "number") {
+      result.calories = calories;
+      hasData = true;
+    } else if (typeof calories === "string") {
+      const parsed = parseFloat(calories.replace(/[^\d.-]/g, ""));
+      if (!isNaN(parsed)) {
+        result.calories = parsed;
+        hasData = true;
+      }
+    }
+  }
+  if ("proteinContent" in nutrition || "protein_g" in nutrition) {
+    const protein = nutrition.proteinContent || nutrition.protein_g;
+    if (typeof protein === "number") {
+      result.protein_g = protein;
+      hasData = true;
+    } else if (typeof protein === "string") {
+      const parsed = parseFloat(protein.replace(/[^\d.-]/g, ""));
+      if (!isNaN(parsed)) {
+        result.protein_g = parsed;
+        hasData = true;
+      }
+    }
+  }
+  return hasData ? result : void 0;
+}
+
+// src/schemas/registry/modules.json
+var modules_default = {
+  modules: [
+    {
+      id: "attribution",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/attribution",
+      schema: "https://soustack.org/schemas/recipe/modules/attribution/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "taxonomy",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/taxonomy",
+      schema: "https://soustack.org/schemas/recipe/modules/taxonomy/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "high",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "media",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/media",
+      schema: "https://soustack.org/schemas/recipe/modules/media/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "nutrition",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/nutrition",
+      schema: "https://soustack.org/schemas/recipe/modules/nutrition/1.schema.json",
+      schemaOrgMappable: false,
+      schemaOrgConfidence: "low",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "times",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/times",
+      schema: "https://soustack.org/schemas/recipe/modules/times/1.schema.json",
+      schemaOrgMappable: true,
+      schemaOrgConfidence: "medium",
+      minProfile: "minimal",
+      allowedOnMinimal: true
+    },
+    {
+      id: "schedule",
+      versions: [
+        1
+      ],
+      latest: 1,
+      namespace: "https://soustack.org/schemas/recipe/modules/schedule",
+      schema: "https://soustack.org/schemas/recipe/modules/schedule/1.schema.json",
+      schemaOrgMappable: false,
+      schemaOrgConfidence: "low",
+      minProfile: "core",
+      allowedOnMinimal: false
+    }
+  ]
+};
 
 // src/converters/toSchemaOrg.ts
 function convertBasicMetadata(recipe) {
@@ -729,6 +915,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;
@@ -767,33 +969,58 @@ function convertCategoryTags(category, tags) {
   }
   return result;
 }
-function convertNutrition(nutrition) {
+function convertNutrition2(nutrition) {
   if (!nutrition) {
     return void 0;
   }
-  return {
-    ...nutrition,
+  const result = {
     "@type": "NutritionInformation"
   };
+  if (nutrition.calories !== void 0) {
+    if (typeof nutrition.calories === "number") {
+      result.calories = `${nutrition.calories} calories`;
+    } else {
+      result.calories = nutrition.calories;
+    }
+  }
+  Object.keys(nutrition).forEach((key) => {
+    if (key !== "calories" && key !== "@type") {
+      result[key] = nutrition[key];
+    }
+  });
+  return result;
 }
 function cleanOutput(obj) {
   return Object.fromEntries(
     Object.entries(obj).filter(([, value]) => value !== void 0)
   );
 }
+function getSchemaOrgMappableModules(modules = []) {
+  const mappableModules = modules_default.modules.filter((m) => m.schemaOrgMappable).map((m) => `${m.id}@${m.latest}`);
+  return modules.filter((moduleId) => mappableModules.includes(moduleId));
+}
 function toSchemaOrg(recipe) {
   const base = convertBasicMetadata(recipe);
   const ingredients = convertIngredients2(recipe.ingredients);
   const instructions = convertInstructions2(recipe.instructions);
-  const nutrition = convertNutrition(recipe.nutrition);
+  const recipeModules = Array.isArray(recipe.modules) ? recipe.modules : [];
+  const mappableModules = getSchemaOrgMappableModules(recipeModules);
+  const hasMappableNutrition = mappableModules.includes("nutrition@1");
+  const nutrition = hasMappableNutrition ? convertNutrition2(recipe.nutrition) : void 0;
+  const hasMappableTimes = mappableModules.includes("times@1");
+  const timeData = hasMappableTimes ? recipe.times ? convertTimesModule(recipe.times) : convertTime2(recipe.time) : {};
+  const hasMappableAttribution = mappableModules.includes("attribution@1");
+  const attributionData = hasMappableAttribution ? convertAuthor(recipe.source) : {};
+  const hasMappableTaxonomy = mappableModules.includes("taxonomy@1");
+  const taxonomyData = hasMappableTaxonomy ? convertCategoryTags(recipe.category, recipe.tags) : {};
   return cleanOutput({
     ...base,
     recipeIngredient: ingredients.length ? ingredients : void 0,
     recipeInstructions: instructions.length ? instructions : void 0,
     recipeYield: convertYield(recipe.yield),
-    ...convertTime2(recipe.time),
-    ...convertAuthor(recipe.source),
-    ...convertCategoryTags(recipe.category, recipe.tags),
+    ...timeData,
+    ...attributionData,
+    ...taxonomyData,
     nutrition
   });
 }
@@ -1226,894 +1453,523 @@ async function scrapeRecipe(url, options = {}) {
   return soustackRecipe;
 }
 
-// src/schema.json
-var schema_default = {
+// src/schemas/recipe/base.schema.json
+var base_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2.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 modules 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"
-    },
-    title: {
-      type: "string",
-      description: "Optional display title; alias for name"
+    "@type": {
+      const: "Recipe",
+      description: "Document marker for Soustack recipes"
     },
-    version: {
+    profile: {
       type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "DEPRECATED: use recipeVersion for authoring revisions"
+      description: "Profile identifier applied to this recipe"
     },
-    recipeVersion: {
-      type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
-    },
-    description: {
-      type: "string"
-    },
-    category: {
-      type: "string",
-      examples: ["Main Course", "Dessert"]
-    },
-    tags: {
+    modules: {
       type: "array",
-      items: { type: "string" }
-    },
-    image: {
-      description: "Recipe-level hero image(s)",
-      anyOf: [
-        {
-          type: "string",
-          format: "uri"
-        },
-        {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "string",
-            format: "uri"
-          }
-        }
-      ]
-    },
-    dateAdded: {
-      type: "string",
-      format: "date-time"
-    },
-    metadata: {
-      type: "object",
-      additionalProperties: true,
-      description: "Free-form vendor metadata"
-    },
-    source: {
-      type: "object",
-      properties: {
-        author: { type: "string" },
-        url: { type: "string", format: "uri" },
-        name: { type: "string" },
-        adapted: { type: "boolean" }
+      description: "List of module identifiers applied to this recipe",
+      items: {
+        type: "string"
       }
     },
-    yield: {
-      $ref: "#/definitions/yield"
-    },
-    time: {
-      $ref: "#/definitions/time"
-    },
-    equipment: {
-      type: "array",
-      items: { $ref: "#/definitions/equipment" }
+    name: {
+      type: "string",
+      description: "Human-readable recipe name"
     },
     ingredients: {
       type: "array",
-      items: {
-        anyOf: [
-          { type: "string" },
-          { $ref: "#/definitions/ingredient" },
-          { $ref: "#/definitions/ingredientSubsection" }
-        ]
-      }
+      description: "Ingredients payload; content is validated by profiles/modules"
     },
     instructions: {
       type: "array",
-      items: {
-        anyOf: [
-          { type: "string" },
-          { $ref: "#/definitions/instruction" },
-          { $ref: "#/definitions/instructionSubsection" }
-        ]
-      }
-    },
-    storage: {
-      $ref: "#/definitions/storage"
-    },
-    substitutions: {
-      type: "array",
-      items: { $ref: "#/definitions/substitution" }
+      description: "Instruction payload; content is validated by profiles/modules"
     }
   },
-  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: {
+  required: ["@type"]
+};
+
+// src/schemas/recipe/profiles/core.schema.json
+var core_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/recipe/profiles/core.schema.json",
+  title: "Soustack Recipe Core Profile",
+  description: "Core profile that builds on the minimal profile and is intended to be combined with recipe modules.",
+  allOf: [
+    { $ref: "http://soustack.org/schema/recipe/base.schema.json" },
+    {
       type: "object",
-      required: ["type"],
       properties: {
-        type: {
-          type: "string",
-          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
+        profile: { const: "core" },
+        modules: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
         },
-        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"],
-      properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: { $ref: "#/definitions/ingredient" }
-        }
-      }
-    },
-    equipment: {
-      type: "object",
-      required: ["name"],
-      properties: {
-        id: { type: "string" },
-        name: { type: "string" },
-        required: { type: "boolean" },
-        label: { type: "string" },
-        capacity: { $ref: "#/definitions/quantity" },
-        scalingLimit: { type: "number" },
-        alternatives: {
-          type: "array",
-          items: { type: "string" }
-        }
-      }
+      required: ["profile", "name", "ingredients", "instructions"],
+      additionalProperties: true
+    }
+  ]
+};
+
+// src/schemas/recipe/profiles/minimal.schema.json
+var minimal_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "http://soustack.org/schema/recipe/profiles/minimal.schema.json",
+  title: "Soustack Recipe Minimal Profile",
+  description: "Minimal profile that ensures the basic Recipe structure is present while allowing modules to extend it.",
+  allOf: [
+    {
+      $ref: "http://soustack.org/schema/recipe/base.schema.json"
     },
-    instruction: {
+    {
       type: "object",
-      required: ["text"],
       properties: {
-        id: { type: "string" },
-        text: { type: "string" },
-        image: {
-          type: "string",
-          format: "uri",
-          description: "Optional image that illustrates this instruction"
+        profile: {
+          const: "minimal"
         },
-        destination: { type: "string" },
-        dependsOn: {
-          type: "array",
-          items: { type: "string" }
-        },
-        inputs: {
-          type: "array",
-          items: { type: "string" }
-        },
-        timing: {
-          type: "object",
-          required: ["duration", "type"],
-          properties: {
-            duration: {
-              anyOf: [
-                { type: "number" },
-                { type: "string", pattern: "^P" }
-              ],
-              description: "Minutes as a number or ISO8601 duration string"
-            },
-            type: { type: "string", enum: ["active", "passive"] },
-            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
-          }
-        }
-      }
-    },
-    instructionSubsection: {
-      type: "object",
-      required: ["subsection", "items"],
-      properties: {
-        subsection: { type: "string" },
-        items: {
+        modules: {
           type: "array",
           items: {
-            anyOf: [
-              { type: "string" },
-              { $ref: "#/definitions/instruction" }
+            type: "string",
+            enum: [
+              "attribution@1",
+              "taxonomy@1",
+              "media@1",
+              "nutrition@1",
+              "times@1"
             ]
-          }
-        }
-      }
-    },
-    storage: {
-      type: "object",
-      properties: {
-        roomTemp: { $ref: "#/definitions/storageMethod" },
-        refrigerated: { $ref: "#/definitions/storageMethod" },
-        frozen: {
-          allOf: [
-            { $ref: "#/definitions/storageMethod" },
-            {
-              type: "object",
-              properties: { thawing: { type: "string" } }
-            }
-          ]
+          },
+          default: []
         },
-        reheating: { type: "string" },
-        makeAhead: {
+        name: {
+          type: "string",
+          minLength: 1
+        },
+        ingredients: {
           type: "array",
-          items: {
-            allOf: [
-              { $ref: "#/definitions/storageMethod" },
-              {
-                type: "object",
-                required: ["component", "storage"],
-                properties: {
-                  component: { type: "string" },
-                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
-                }
-              }
-            ]
-          }
-        }
-      }
-    },
-    storageMethod: {
-      type: "object",
-      required: ["duration"],
-      properties: {
-        duration: { type: "string", pattern: "^P" },
-        method: { type: "string" },
-        notes: { type: "string" }
-      }
-    },
-    substitution: {
-      type: "object",
-      required: ["ingredient"],
-      properties: {
-        ingredient: { type: "string" },
-        critical: { type: "boolean" },
-        notes: { type: "string" },
-        alternatives: {
+          minItems: 1
+        },
+        instructions: {
           type: "array",
-          items: {
-            type: "object",
-            required: ["name", "ratio"],
-            properties: {
-              name: { type: "string" },
-              ratio: { type: "string" },
-              notes: { type: "string" },
-              impact: { type: "string" },
-              dietary: {
-                type: "array",
-                items: { type: "string" }
-              }
-            }
-          }
+          minItems: 1
         }
-      }
+      },
+      required: [
+        "profile",
+        "name",
+        "ingredients",
+        "instructions"
+      ],
+      additionalProperties: true
     }
-  }
+  ]
 };
 
-// src/soustack.schema.json
-var soustack_schema_default = {
+// src/schemas/recipe/modules/schedule/1.schema.json
+var schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2.1",
-  title: "Soustack Recipe Schema v0.2.1",
-  description: "A portable, scalable, interoperable recipe format.",
+  $id: "https://soustack.org/schemas/recipe/modules/schedule/1.schema.json",
+  title: "Soustack Recipe Module: schedule v1",
+  description: "Schema for the schedule module. Enforces bidirectional module gating and restricts usage to the core profile.",
   type: "object",
-  required: ["name", "ingredients", "instructions"],
-  additionalProperties: false,
-  patternProperties: {
-    "^x-": {}
-  },
   properties: {
-    $schema: {
-      type: "string",
-      format: "uri",
-      description: "Optional schema hint for tooling compatibility"
-    },
-    id: {
-      type: "string",
-      description: "Unique identifier (slug or UUID)"
-    },
-    name: {
-      type: "string",
-      description: "The title of the recipe"
-    },
-    title: {
-      type: "string",
-      description: "Optional display title; alias for name"
-    },
-    version: {
-      type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "DEPRECATED: use recipeVersion for authoring revisions"
-    },
-    recipeVersion: {
-      type: "string",
-      pattern: "^\\d+\\.\\d+\\.\\d+$",
-      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
-    },
-    description: {
-      type: "string"
-    },
-    category: {
-      type: "string",
-      examples: ["Main Course", "Dessert"]
-    },
-    tags: {
+    profile: { type: "string" },
+    modules: {
       type: "array",
       items: { type: "string" }
     },
-    image: {
-      description: "Recipe-level hero image(s)",
-      anyOf: [
-        {
-          type: "string",
-          format: "uri"
-        },
-        {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "string",
-            format: "uri"
-          }
-        }
-      ]
-    },
-    dateAdded: {
-      type: "string",
-      format: "date-time"
-    },
-    metadata: {
-      type: "object",
-      additionalProperties: true,
-      description: "Free-form vendor metadata"
-    },
-    source: {
+    schedule: {
       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" }
+        tasks: { type: "array" }
+      },
+      additionalProperties: false
     }
   },
-  definitions: {
-    yield: {
-      type: "object",
-      required: ["amount", "unit"],
-      properties: {
-        amount: { type: "number" },
-        unit: { type: "string" },
-        servings: { type: "number" },
-        description: { type: "string" }
-      }
-    },
-    time: {
-      type: "object",
-      properties: {
-        prep: { type: "number" },
-        active: { type: "number" },
-        passive: { type: "number" },
-        total: { type: "number" },
-        prepTime: { type: "string", format: "duration" },
-        cookTime: { type: "string", format: "duration" }
-      },
-      minProperties: 1
-    },
-    quantity: {
-      type: "object",
-      required: ["amount"],
-      properties: {
-        amount: { type: "number" },
-        unit: { type: ["string", "null"] }
-      }
-    },
-    scaling: {
-      type: "object",
-      required: ["type"],
-      properties: {
-        type: {
-          type: "string",
-          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
-        },
-        factor: { type: "number" },
-        referenceId: { type: "string" },
-        roundTo: { type: "number" },
-        min: { type: "number" },
-        max: { type: "number" }
-      },
+  allOf: [
+    {
       if: {
-        properties: { type: { const: "bakers_percentage" } }
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "schedule@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"],
-      properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: { $ref: "#/definitions/ingredient" }
+        required: ["schedule", "profile"],
+        properties: {
+          profile: { const: "core" }
         }
       }
     },
-    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" }
+    {
+      if: {
+        required: ["schedule"]
+      },
+      then: {
+        required: ["modules", "profile"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "schedule@1" }
+          },
+          profile: { const: "core" }
         }
       }
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/nutrition/1.schema.json
+var schema_default2 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/nutrition/1.schema.json",
+  title: "Soustack Recipe Module: nutrition v1",
+  description: "Schema for the nutrition module. Keeps nutrition data aligned with module declarations and vice versa.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    instruction: {
+    nutrition: {
       type: "object",
-      required: ["text"],
       properties: {
-        id: { type: "string" },
-        text: { type: "string" },
-        image: {
-          type: "string",
-          format: "uri",
-          description: "Optional image that illustrates this instruction"
-        },
-        destination: { type: "string" },
-        dependsOn: {
-          type: "array",
-          items: { type: "string" }
-        },
-        inputs: {
-          type: "array",
-          items: { type: "string" }
-        },
-        timing: {
-          type: "object",
-          required: ["duration", "type"],
-          properties: {
-            duration: {
-              anyOf: [
-                { type: "number" },
-                { type: "string", pattern: "^P" }
-              ],
-              description: "Minutes as a number or ISO8601 duration string"
-            },
-            type: { type: "string", enum: ["active", "passive"] },
-            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+        calories: { type: "number" },
+        protein_g: { type: "number" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "nutrition@1" }
           }
         }
+      },
+      then: {
+        required: ["nutrition"]
       }
     },
-    instructionSubsection: {
-      type: "object",
-      required: ["subsection", "items"],
-      properties: {
-        subsection: { type: "string" },
-        items: {
-          type: "array",
-          items: {
-            anyOf: [
-              { type: "string" },
-              { $ref: "#/definitions/instruction" }
-            ]
+    {
+      if: {
+        required: ["nutrition"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "nutrition@1" }
           }
         }
       }
+    }
+  ],
+  additionalProperties: true
+};
+
+// src/schemas/recipe/modules/attribution/1.schema.json
+var schema_default3 = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://soustack.org/schemas/recipe/modules/attribution/1.schema.json",
+  title: "Soustack Recipe Module: attribution v1",
+  description: "Schema for the attribution module. Ensures namespace data is present when the module is enabled and vice versa.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
     },
-    storage: {
+    attribution: {
       type: "object",
       properties: {
-        roomTemp: { $ref: "#/definitions/storageMethod" },
-        refrigerated: { $ref: "#/definitions/storageMethod" },
-        frozen: {
-          allOf: [
-            { $ref: "#/definitions/storageMethod" },
-            {
-              type: "object",
-              properties: { thawing: { type: "string" } }
-            }
-          ]
-        },
-        reheating: { type: "string" },
-        makeAhead: {
-          type: "array",
-          items: {
-            allOf: [
-              { $ref: "#/definitions/storageMethod" },
-              {
-                type: "object",
-                required: ["component", "storage"],
-                properties: {
-                  component: { type: "string" },
-                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
-                }
-              }
-            ]
+        url: { type: "string" },
+        author: { type: "string" },
+        datePublished: { type: "string" }
+      },
+      additionalProperties: false
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "attribution@1" }
           }
         }
+      },
+      then: {
+        required: ["attribution"]
       }
     },
-    storageMethod: {
-      type: "object",
-      required: ["duration"],
-      properties: {
-        duration: { type: "string", pattern: "^P" },
-        method: { type: "string" },
-        notes: { type: "string" }
-      }
-    },
-    substitution: {
-      type: "object",
-      required: ["ingredient"],
-      properties: {
-        ingredient: { type: "string" },
-        critical: { type: "boolean" },
-        notes: { type: "string" },
-        alternatives: {
-          type: "array",
-          items: {
-            type: "object",
-            required: ["name", "ratio"],
-            properties: {
-              name: { type: "string" },
-              ratio: { type: "string" },
-              notes: { type: "string" },
-              impact: { type: "string" },
-              dietary: {
-                type: "array",
-                items: { type: "string" }
-              }
-            }
+    {
+      if: {
+        required: ["attribution"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "attribution@1" }
           }
         }
       }
     }
-  }
-};
-
-// src/profiles/base.schema.json
-var base_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2.1/profiles/base",
-  title: "Soustack Base Profile Schema",
-  description: "Wrapper schema that exposes the unmodified Soustack base schema.",
-  allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" }
-  ]
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/cookable.schema.json
-var cookable_schema_default = {
+// src/schemas/recipe/modules/taxonomy/1.schema.json
+var schema_default4 = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2.1/profiles/cookable",
-  title: "Soustack Cookable Profile Schema",
-  description: "Extends the base schema to require structured yield + time metadata and non-empty ingredient/instruction lists.",
-  allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" },
-    {
-      required: ["yield", "time", "ingredients", "instructions"],
+  $id: "https://soustack.org/schemas/recipe/modules/taxonomy/1.schema.json",
+  title: "Soustack Recipe Module: taxonomy v1",
+  description: "Schema for the taxonomy module. Enforces keyword and categorization data when enabled and ensures module declaration accompanies the namespace block.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
+    },
+    taxonomy: {
+      type: "object",
       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 }
-      }
+        keywords: { type: "array", items: { type: "string" } },
+        category: { type: "string" },
+        cuisine: { type: "string" }
+      },
+      additionalProperties: false
     }
-  ]
-};
-
-// src/profiles/quantified.schema.json
-var quantified_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "http://soustack.org/schema/v0.2.1/profiles/quantified",
-  title: "Soustack Quantified Profile Schema",
-  description: "Extends the base schema to require quantified ingredient entries.",
+  },
   allOf: [
-    { $ref: "http://soustack.org/schema/v0.2.1" },
     {
-      properties: {
-        ingredients: {
-          type: "array",
-          items: {
-            anyOf: [
-              { $ref: "#/definitions/quantifiedIngredient" },
-              { $ref: "#/definitions/quantifiedIngredientSubsection" }
-            ]
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "taxonomy@1" }
           }
         }
+      },
+      then: {
+        required: ["taxonomy"]
       }
-    }
-  ],
-  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: ["taxonomy"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "taxonomy@1" }
           }
         }
-      ]
+      }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/illustrated.schema.json
-var illustrated_schema_default = {
+// src/schemas/recipe/modules/media/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/modules/media/1.schema.json",
+  title: "Soustack Recipe Module: media v1",
+  description: "Schema for the media module. Guards media blocks based on module activation and ensures declarations accompany payloads.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
+    },
+    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" },
     {
-      anyOf: [
-        { required: ["image"] },
-        {
-          properties: {
-            instructions: {
-              type: "array",
-              contains: {
-                anyOf: [
-                  { $ref: "#/definitions/imageInstruction" },
-                  { $ref: "#/definitions/instructionSubsectionWithImage" }
-                ]
-              }
-            }
+      if: {
+        properties: {
+          modules: {
+            type: "array",
+            contains: { const: "media@1" }
           }
         }
-      ]
-    }
-  ],
-  definitions: {
-    imageInstruction: {
-      allOf: [
-        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instruction" },
-        { required: ["image"] }
-      ]
+      },
+      then: {
+        required: ["media"]
+      }
     },
-    instructionSubsectionWithImage: {
-      allOf: [
-        { $ref: "http://soustack.org/schema/v0.2.1#/definitions/instructionSubsection" },
-        {
-          properties: {
-            items: {
-              type: "array",
-              contains: { $ref: "#/definitions/imageInstruction" }
-            }
+    {
+      if: {
+        required: ["media"]
+      },
+      then: {
+        required: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "media@1" }
           }
         }
-      ]
+      }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
-// src/profiles/schedulable.schema.json
-var schedulable_schema_default = {
+// src/schemas/recipe/modules/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/modules/times/1.schema.json",
+  title: "Soustack Recipe Module: times v1",
+  description: "Schema for the times module. Maintains alignment between module declarations and timing payloads.",
+  type: "object",
+  properties: {
+    modules: {
+      type: "array",
+      items: { type: "string" }
+    },
+    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: {
+          modules: {
+            type: "array",
+            contains: { const: "times@1" }
           }
         }
+      },
+      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: ["modules"],
+        properties: {
+          modules: {
+            type: "array",
+            items: { type: "string" },
+            contains: { const: "times@1" }
           }
         }
-      ]
+      }
     }
-  }
+  ],
+  additionalProperties: true
 };
 
 // src/validator.ts
+var CANONICAL_BASE_SCHEMA_ID = base_schema_default.$id || "http://soustack.org/schema/recipe/base.schema.json";
+var canonicalProfileId = (profile) => {
+  if (profile === "minimal") {
+    return minimal_schema_default.$id;
+  }
+  if (profile === "core") {
+    return core_schema_default.$id;
+  }
+  throw new Error(`Unknown profile: ${profile}`);
+};
+var moduleIdToSchemaRef = (moduleId) => {
+  const match = moduleId.match(/^([a-z0-9_-]+)@(\d+(?:\.\d+)*)$/i);
+  if (!match) {
+    throw new Error(`Invalid module identifier '${moduleId}'. Expected <name>@<version>.`);
+  }
+  const [, name, version] = match;
+  const moduleSchemas2 = {
+    "schedule@1": schema_default,
+    "nutrition@1": schema_default2,
+    "attribution@1": schema_default3,
+    "taxonomy@1": schema_default4,
+    "media@1": schema_default5,
+    "times@1": schema_default6
+  };
+  const schema = moduleSchemas2[moduleId];
+  if (schema && schema.$id) {
+    return schema.$id;
+  }
+  return `https://soustack.org/schemas/recipe/modules/${name}/${version}.schema.json`;
+};
 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
+  minimal: minimal_schema_default,
+  core: core_schema_default
+};
+var moduleSchemas = {
+  "schedule@1": schema_default,
+  "nutrition@1": schema_default2,
+  "attribution@1": schema_default3,
+  "taxonomy@1": schema_default4,
+  "media@1": schema_default5,
+  "times@1": schema_default6
 };
 var validationContexts = /* @__PURE__ */ new Map();
 function createContext(collectAllErrors) {
   const ajv = new Ajv__default.default({ strict: false, allErrors: collectAllErrors });
   addFormats__default.default(ajv);
-  const loadedIds = /* @__PURE__ */ new Set();
-  const addSchemaIfNew = (schema) => {
+  const addSchemaWithAlias = (schema, alias) => {
     if (!schema) return;
-    const schemaId = schema?.$id;
-    if (schemaId && loadedIds.has(schemaId)) return;
-    ajv.addSchema(schema);
-    if (schemaId) loadedIds.add(schemaId);
+    const schemaId = schema.$id || alias;
+    if (schemaId) {
+      ajv.addSchema(schema, schemaId);
+    } else {
+      ajv.addSchema(schema);
+    }
   };
-  addSchemaIfNew(schema_default);
-  addSchemaIfNew(soustack_schema_default);
-  Object.values(profileSchemas).forEach(addSchemaIfNew);
-  return { ajv, validators: {} };
+  addSchemaWithAlias(base_schema_default, CANONICAL_BASE_SCHEMA_ID);
+  Object.entries(profileSchemas).forEach(([name, schema]) => {
+    addSchemaWithAlias(schema, canonicalProfileId(name));
+  });
+  Object.entries(moduleSchemas).forEach(([moduleId, schema]) => {
+    addSchemaWithAlias(schema, moduleIdToSchemaRef(moduleId));
+  });
+  return { ajv, validators: /* @__PURE__ */ new Map() };
 }
 function getContext(collectAllErrors) {
   if (!validationContexts.has(collectAllErrors)) {
@@ -2136,14 +1992,58 @@ function detectProfileFromSchema(schemaRef) {
   }
   return void 0;
 }
-function getValidator(profile, context) {
+function resolveSchemaRef(inputSchema, requestedSchema) {
+  if (typeof requestedSchema === "string") return requestedSchema;
+  if (typeof inputSchema !== "string") return void 0;
+  return detectProfileFromSchema(inputSchema) ? inputSchema : void 0;
+}
+function inferModulesFromPayload(recipe) {
+  const inferred = [];
+  const payloadToModule = {
+    attribution: "attribution@1",
+    taxonomy: "taxonomy@1",
+    media: "media@1",
+    times: "times@1",
+    nutrition: "nutrition@1",
+    schedule: "schedule@1"
+  };
+  for (const [field, moduleId] of Object.entries(payloadToModule)) {
+    if (recipe && typeof recipe === "object" && field in recipe && recipe[field] != null) {
+      const payload = recipe[field];
+      if (typeof payload === "object" && !Array.isArray(payload)) {
+        if (Object.keys(payload).length > 0) {
+          inferred.push(moduleId);
+        }
+      } else if (Array.isArray(payload) && payload.length > 0) {
+        inferred.push(moduleId);
+      } else if (payload !== null && payload !== void 0) {
+        inferred.push(moduleId);
+      }
+    }
+  }
+  return inferred;
+}
+function getCombinedValidator(profile, modules, recipe, context) {
+  const inferredModules = inferModulesFromPayload(recipe);
+  const allModules = /* @__PURE__ */ new Set([...modules, ...inferredModules]);
+  const sortedModules = Array.from(allModules).sort();
+  const cacheKey = `${profile}::${sortedModules.join(",")}`;
+  const cached = context.validators.get(cacheKey);
+  if (cached) return cached;
   if (!profileSchemas[profile]) {
     throw new Error(`Unknown Soustack profile: ${profile}`);
   }
-  if (!context.validators[profile]) {
-    context.validators[profile] = context.ajv.compile(profileSchemas[profile]);
-  }
-  return context.validators[profile];
+  const schema = {
+    $id: `urn:soustack:recipe:${cacheKey}`,
+    allOf: [
+      { $ref: CANONICAL_BASE_SCHEMA_ID },
+      { $ref: canonicalProfileId(profile) },
+      ...sortedModules.map((moduleId) => ({ $ref: moduleIdToSchemaRef(moduleId) }))
+    ]
+  };
+  const validateFn = context.ajv.compile(schema);
+  context.validators.set(cacheKey, validateFn);
+  return validateFn;
 }
 function normalizeRecipe(recipe) {
   const normalized = cloneRecipe(recipe);
@@ -2174,9 +2074,33 @@ function normalizeTime(recipe) {
   });
 }
 var allowedTopLevelProps = /* @__PURE__ */ new Set([
-  ...Object.keys(soustack_schema_default?.properties ?? {}),
-  "metadata",
-  "$schema"
+  ...Object.keys(base_schema_default?.properties ?? {}),
+  "$schema",
+  // Module fields (validated by module schemas)
+  "attribution",
+  "taxonomy",
+  "media",
+  "times",
+  "nutrition",
+  "schedule",
+  // Common recipe fields (allowed by base schema's additionalProperties: true)
+  "description",
+  "image",
+  "category",
+  "tags",
+  "source",
+  "dateAdded",
+  "dateModified",
+  "yield",
+  "time",
+  "id",
+  "title",
+  "recipeVersion",
+  "version",
+  // deprecated but allowed
+  "equipment",
+  "storage",
+  "substitutions"
 ]);
 function detectUnknownTopLevelKeys(recipe) {
   if (!recipe || typeof recipe !== "object") return [];
@@ -2201,11 +2125,19 @@ function formatAjvError(error) {
     message: error.message || "Validation error"
   };
 }
-function runAjvValidation(data, profile, context, schemaRef) {
-  const validator = schemaRef ? context.ajv.getSchema(schemaRef) : void 0;
-  const validateFn = validator ?? getValidator(profile, context);
-  const isValid = validateFn(data);
-  return !isValid && validateFn.errors ? validateFn.errors.map(formatAjvError) : [];
+function runAjvValidation(data, profile, modules, context) {
+  try {
+    const validateFn = getCombinedValidator(profile, modules, data, context);
+    const isValid = validateFn(data);
+    return !isValid && validateFn.errors ? validateFn.errors.map(formatAjvError) : [];
+  } catch (error) {
+    return [
+      {
+        path: "/",
+        message: error instanceof Error ? error.message : "Validation failed to initialize"
+      }
+    ];
+  }
 }
 function isInstruction(item) {
   return item && typeof item === "object" && !Array.isArray(item) && "text" in item;
@@ -2286,12 +2218,25 @@ function checkInstructionGraph(recipe) {
 function validateRecipe(input, options = {}) {
   const collectAllErrors = options.collectAllErrors ?? true;
   const context = getContext(collectAllErrors);
-  const schemaRef = options.schema ?? (typeof input?.$schema === "string" ? input.$schema : void 0);
-  const profile = options.profile ?? detectProfileFromSchema(schemaRef) ?? "base";
+  const schemaRef = resolveSchemaRef(input?.$schema, options.schema);
+  const profileFromDocument = typeof input?.profile === "string" ? input.profile : void 0;
+  const profile = options.profile ?? profileFromDocument ?? detectProfileFromSchema(schemaRef) ?? "core";
+  const modulesFromDocument = Array.isArray(input?.modules) ? input.modules.filter((value) => typeof value === "string") : [];
+  const modules = modulesFromDocument.length > 0 ? [...modulesFromDocument].sort() : [];
   const { normalized, warnings } = normalizeRecipe(input);
+  if (!profileFromDocument) {
+    normalized.profile = profile;
+  } else {
+    normalized.profile = profileFromDocument;
+  }
+  if (!("modules" in normalized) || normalized.modules === void 0 || normalized.modules === null) {
+    normalized.modules = [];
+  } else if (modulesFromDocument.length > 0) {
+    normalized.modules = modules;
+  }
   const unknownKeyErrors = detectUnknownTopLevelKeys(normalized);
-  const validationErrors = runAjvValidation(normalized, profile, context, schemaRef);
-  const graphErrors = profile === "schedulable" && validationErrors.length === 0 ? checkInstructionGraph(normalized) : [];
+  const validationErrors = runAjvValidation(normalized, profile, modules, context);
+  const graphErrors = modules.includes("schedule@1") && validationErrors.length === 0 ? checkInstructionGraph(normalized) : [];
   const errors = [...unknownKeyErrors, ...validationErrors, ...graphErrors];
   return {
     valid: errors.length === 0,