soustack 0.3.0 → 0.4.0

package/dist/cli/index.js

@@ -5,7 +5,7 @@ var fs = require('fs');
 var path = require('path');
 var glob = require('glob');
 var cheerio = require('cheerio');
-var Ajv = require('ajv');
+var Ajv2020 = require('ajv/dist/2020');
 var addFormats = require('ajv-formats');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -30,7 +30,7 @@ function _interopNamespace(e) {
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+var Ajv2020__default = /*#__PURE__*/_interopDefault(Ajv2020);
 var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -351,6 +351,92 @@ function extractUrl(value) {
   return trimmed || void 0;
 }
 
+// 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?.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/fromSchemaOrg.ts
 function fromSchemaOrg(input) {
   const recipeNode = extractRecipeNode(input);
@@ -370,16 +456,16 @@ function fromSchemaOrg(input) {
   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 {
+  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",
-    modules: modules.sort(),
+    stacks,
     name: recipeNode.name.trim(),
     description: recipeNode.description?.trim() || void 0,
     image: normalizeImage(recipeNode.image),
@@ -398,6 +484,8 @@ function fromSchemaOrg(input) {
     ...media ? { media } : {},
     ...times ? { times } : {}
   };
+  const { recipe } = normalizeRecipe(rawRecipe);
+  return recipe;
 }
 function extractRecipeNode(input) {
   if (!input) return null;
@@ -694,17 +782,15 @@ function convertNutrition(nutrition) {
   return hasData ? result : void 0;
 }
 
-// src/schemas/registry/modules.json
-var modules_default = {
-  modules: [
+// src/schemas/registry/stacks.json
+var stacks_default = {
+  stacks: [
     {
       id: "attribution",
-      versions: [
-        1
-      ],
+      versions: [1],
       latest: 1,
-      namespace: "https://soustack.org/schemas/recipe/modules/attribution",
-      schema: "https://soustack.org/schemas/recipe/modules/attribution/1.schema.json",
+      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",
@@ -712,12 +798,10 @@ var modules_default = {
     },
     {
       id: "taxonomy",
-      versions: [
-        1
-      ],
+      versions: [1],
       latest: 1,
-      namespace: "https://soustack.org/schemas/recipe/modules/taxonomy",
-      schema: "https://soustack.org/schemas/recipe/modules/taxonomy/1.schema.json",
+      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",
@@ -725,12 +809,10 @@ var modules_default = {
     },
     {
       id: "media",
-      versions: [
-        1
-      ],
+      versions: [1],
       latest: 1,
-      namespace: "https://soustack.org/schemas/recipe/modules/media",
-      schema: "https://soustack.org/schemas/recipe/modules/media/1.schema.json",
+      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",
@@ -738,12 +820,10 @@ var modules_default = {
     },
     {
       id: "nutrition",
-      versions: [
-        1
-      ],
+      versions: [1],
       latest: 1,
-      namespace: "https://soustack.org/schemas/recipe/modules/nutrition",
-      schema: "https://soustack.org/schemas/recipe/modules/nutrition/1.schema.json",
+      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",
@@ -751,12 +831,10 @@ var modules_default = {
     },
     {
       id: "times",
-      versions: [
-        1
-      ],
+      versions: [1],
       latest: 1,
-      namespace: "https://soustack.org/schemas/recipe/modules/times",
-      schema: "https://soustack.org/schemas/recipe/modules/times/1.schema.json",
+      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",
@@ -764,12 +842,10 @@ var modules_default = {
     },
     {
       id: "schedule",
-      versions: [
-        1
-      ],
+      versions: [1],
       latest: 1,
-      namespace: "https://soustack.org/schemas/recipe/modules/schedule",
-      schema: "https://soustack.org/schemas/recipe/modules/schedule/1.schema.json",
+      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",
@@ -995,23 +1071,30 @@ function cleanOutput(obj) {
     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 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 recipeModules = Array.isArray(recipe.modules) ? recipe.modules : [];
-  const mappableModules = getSchemaOrgMappableModules(recipeModules);
-  const hasMappableNutrition = mappableModules.includes("nutrition@1");
+  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 = mappableModules.includes("times@1");
+  const hasMappableTimes = mappableStacks.has("times@1");
   const timeData = hasMappableTimes ? recipe.times ? convertTimesModule(recipe.times) : convertTime2(recipe.time) : {};
-  const hasMappableAttribution = mappableModules.includes("attribution@1");
+  const hasMappableAttribution = mappableStacks.has("attribution@1");
   const attributionData = hasMappableAttribution ? convertAuthor(recipe.source) : {};
-  const hasMappableTaxonomy = mappableModules.includes("taxonomy@1");
+  const hasMappableTaxonomy = mappableStacks.has("taxonomy@1");
   const taxonomyData = hasMappableTaxonomy ? convertCategoryTags(recipe.category, recipe.tags) : {};
   return cleanOutput({
     ...base,
@@ -1092,13 +1175,16 @@ async function fetchPage(url, options = {}) {
       const response = await resolvedFetch(url, requestInit);
       clearTimeout(timeoutId);
       if (response && typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-        try {
-          const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-          if (globalFetch) {
-            globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/fetch.ts:63", message: "fetch response", data: { url, status: response.status, statusText: response.statusText, ok: response.ok, isNYTimes: url.includes("nytimes.com") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
-            });
+        const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+        if (ingestUrl) {
+          try {
+            const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+            if (globalFetch) {
+              globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/fetch.ts:63", message: "fetch response", data: { url, status: response.status, statusText: response.statusText, ok: response.ok, isNYTimes: url.includes("nytimes.com") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
+              });
+            }
+          } catch {
           }
-        } catch {
         }
       }
       if (!response.ok) {
@@ -1110,13 +1196,16 @@ async function fetchPage(url, options = {}) {
       }
       const html = await response.text();
       if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-        try {
-          const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-          if (globalFetch) {
-            globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/fetch.ts:75", message: "HTML received", data: { htmlLength: html.length, hasLoginPage: html.toLowerCase().includes("login") || html.toLowerCase().includes("sign in"), hasRecipeData: html.includes("application/ld+json") || html.includes("schema.org/Recipe") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B,D" }) }).catch(() => {
-            });
+        const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+        if (ingestUrl) {
+          try {
+            const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+            if (globalFetch) {
+              globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/fetch.ts:75", message: "HTML received", data: { htmlLength: html.length, hasLoginPage: html.toLowerCase().includes("login") || html.toLowerCase().includes("sign in"), hasRecipeData: html.includes("application/ld+json") || html.includes("schema.org/Recipe") }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B,D" }) }).catch(() => {
+              });
+            }
+          } catch {
           }
-        } catch {
         }
       }
       return html;
@@ -1146,8 +1235,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());
   }
@@ -1175,20 +1262,14 @@ function normalizeText(value) {
 function extractJsonLd(html) {
   const $ = cheerio.load(html);
   const scripts = $('script[type="application/ld+json"]');
-  fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/jsonld.ts:8", message: "JSON-LD scripts found", data: { scriptCount: scripts.length }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
-  });
   const candidates = [];
   scripts.each((_, element) => {
     const content = $(element).html();
     if (!content) return;
     const parsed = safeJsonParse(content);
     if (!parsed) return;
-    fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/jsonld.ts:18", message: "JSON-LD parsed", data: { hasGraph: !!(parsed && typeof parsed === "object" && "@graph" in parsed), type: parsed && typeof parsed === "object" && "@type" in parsed ? parsed["@type"] : void 0 }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C" }) }).catch(() => {
-    });
     collectCandidates(parsed, candidates);
   });
-  fetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/jsonld.ts:22", message: "JSON-LD candidates", data: { candidateCount: candidates.length, candidateTypes: candidates.map((c) => c["@type"]) }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C" }) }).catch(() => {
-  });
   return candidates[0] ?? null;
 }
 function collectCandidates(payload, bucket) {
@@ -1370,13 +1451,16 @@ function extractRecipe(html) {
   }
   const jsonLdRecipe = extractJsonLd(html);
   if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:6", message: "JSON-LD extraction result", data: { hasJsonLd: !!jsonLdRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
-        });
+    const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+    if (ingestUrl) {
+      try {
+        const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+        if (globalFetch) {
+          globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:6", message: "JSON-LD extraction result", data: { hasJsonLd: !!jsonLdRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "C,D" }) }).catch(() => {
+          });
+        }
+      } catch {
       }
-    } catch {
     }
   }
   if (jsonLdRecipe) {
@@ -1384,13 +1468,16 @@ function extractRecipe(html) {
   }
   const microdataRecipe = extractMicrodata(html);
   if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:12", message: "Microdata extraction result", data: { hasMicrodata: !!microdataRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "D" }) }).catch(() => {
-        });
+    const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+    if (ingestUrl) {
+      try {
+        const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+        if (globalFetch) {
+          globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/extractors/index.ts:12", message: "Microdata extraction result", data: { hasMicrodata: !!microdataRecipe }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "D" }) }).catch(() => {
+          });
+        }
+      } catch {
       }
-    } catch {
     }
   }
   if (microdataRecipe) {
@@ -1402,35 +1489,44 @@ function extractRecipe(html) {
 // src/scraper/index.ts
 async function scrapeRecipe(url, options = {}) {
   if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:7", message: "scrapeRecipe entry", data: { url, hasOptions: !!options }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,B,C,D,E" }) }).catch(() => {
-        });
+    const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+    if (ingestUrl) {
+      try {
+        const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+        if (globalFetch) {
+          globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:7", message: "scrapeRecipe entry", data: { url, hasOptions: !!options }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,B,C,D,E" }) }).catch(() => {
+          });
+        }
+      } catch {
       }
-    } catch {
     }
   }
   const html = await fetchPage(url, options);
   if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:9", message: "HTML fetched", data: { htmlLength: html?.length, htmlPreview: html?.substring(0, 200) }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
-        });
+    const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+    if (ingestUrl) {
+      try {
+        const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+        if (globalFetch) {
+          globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:9", message: "HTML fetched", data: { htmlLength: html?.length, htmlPreview: html?.substring(0, 200) }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "B" }) }).catch(() => {
+          });
+        }
+      } catch {
       }
-    } catch {
     }
   }
   const { recipe } = extractRecipe(html);
   if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:11", message: "extractRecipe result", data: { hasRecipe: !!recipe, recipeType: recipe?.["@type"], recipeName: recipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C,D" }) }).catch(() => {
-        });
+    const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+    if (ingestUrl) {
+      try {
+        const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+        if (globalFetch) {
+          globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:11", message: "extractRecipe result", data: { hasRecipe: !!recipe, recipeType: recipe?.["@type"], recipeName: recipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A,C,D" }) }).catch(() => {
+          });
+        }
+      } catch {
       }
-    } catch {
     }
   }
   if (!recipe) {
@@ -1438,13 +1534,16 @@ async function scrapeRecipe(url, options = {}) {
   }
   const soustackRecipe = fromSchemaOrg(recipe);
   if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
-    try {
-      const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
-      if (globalFetch) {
-        globalFetch("http://127.0.0.1:7243/ingest/7225c3b5-9ac2-4c94-b561-807ca9003b66", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:17", message: "fromSchemaOrg result", data: { hasSoustackRecipe: !!soustackRecipe, soustackRecipeName: soustackRecipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
-        });
+    const ingestUrl = process.env.SOUSTACK_DEBUG_INGEST_URL;
+    if (ingestUrl) {
+      try {
+        const globalFetch = typeof globalThis !== "undefined" && typeof globalThis.fetch !== "undefined" ? globalThis.fetch : null;
+        if (globalFetch) {
+          globalFetch(ingestUrl, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "scraper/index.ts:17", message: "fromSchemaOrg result", data: { hasSoustackRecipe: !!soustackRecipe, soustackRecipeName: soustackRecipe?.name }, timestamp: Date.now(), sessionId: "debug-session", runId: "run1", hypothesisId: "A" }) }).catch(() => {
+          });
+        }
+      } catch {
       }
-    } catch {
     }
   }
   if (!soustackRecipe) {
@@ -1453,72 +1552,625 @@ async function scrapeRecipe(url, options = {}) {
   return soustackRecipe;
 }
 
-// src/schemas/recipe/base.schema.json
-var base_schema_default = {
+// 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) => {
+    if (ref.fromId && instructionIds.has(ref.fromId) && instructionIds.has(ref.toId)) {
+      const list = adjacency.get(ref.fromId) ?? [];
+      list.push({ toId: ref.toId, path: ref.path });
+      adjacency.set(ref.fromId, list);
+    }
+  });
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const detectCycles = (nodeId) => {
+    if (visiting.has(nodeId)) {
+      return;
+    }
+    if (visited.has(nodeId)) {
+      return;
+    }
+    visiting.add(nodeId);
+    const neighbors = adjacency.get(nodeId) ?? [];
+    neighbors.forEach((edge) => {
+      if (visiting.has(edge.toId)) {
+        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, path2) => {
+    if (isInstructionSubsection(item)) {
+      if (Array.isArray(item.items)) {
+        item.items.forEach((subItem, index) => {
+          checkInstruction(subItem, `${path2}/items/${index}`);
+        });
+      }
+      return;
+    }
+    if (isInstruction(item)) {
+      if (!item.id) {
+        issues.push({
+          code: "SCHEDULABLE_MISSING_ID",
+          path: path2,
+          message: "Schedulable profile requires all instructions to have an id.",
+          severity: "error"
+        });
+      }
+      if (!item.timing) {
+        issues.push({
+          code: "SCHEDULABLE_MISSING_TIMING",
+          path: path2,
+          message: "Schedulable profile requires all instructions to have timing information.",
+          severity: "error"
+        });
+      } else if (!item.timing.duration) {
+        issues.push({
+          code: "SCHEDULABLE_MISSING_DURATION",
+          path: `${path2}/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, path2) => {
+    if (isIngredientSubsection(item)) {
+      if (Array.isArray(item.items)) {
+        item.items.forEach((subItem, index) => {
+          checkIngredient(subItem, `${path2}/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: `${path2}/scaling/referenceId`,
+              message: `Baker's percentage references missing ingredient id '${bakersScaling.referenceId}'.`,
+              severity: "error"
+            });
+          }
+        } else {
+          issues.push({
+            code: "SCALING_MISSING_REFERENCE",
+            path: `${path2}/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/recipe/base.schema.json",
-  title: "Soustack Recipe Base Schema",
-  description: "Base document shape for Soustack recipe documents. Profiles and modules build on this baseline.",
+  $id: "http://soustack.org/schema/v0.3.0",
+  title: "Soustack Recipe Schema v0.3.0",
+  description: "A portable, scalable, interoperable recipe format.",
   type: "object",
-  additionalProperties: true,
+  required: ["name", "ingredients", "instructions"],
+  additionalProperties: false,
+  patternProperties: {
+    "^x-": {}
+  },
   properties: {
-    "@type": {
-      const: "Recipe",
-      description: "Document marker for Soustack recipes"
+    $schema: {
+      type: "string",
+      format: "uri",
+      description: "Optional schema hint for tooling compatibility"
     },
-    profile: {
+    id: {
       type: "string",
-      description: "Profile identifier applied to this recipe"
+      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"
     },
-    modules: {
+    recipeVersion: {
+      type: "string",
+      pattern: "^\\d+\\.\\d+\\.\\d+$",
+      description: "Recipe content revision (semantic versioning, e.g., 1.0.0)"
+    },
+    description: {
+      type: "string"
+    },
+    category: {
+      type: "string",
+      examples: ["Main Course", "Dessert"]
+    },
+    tags: {
       type: "array",
-      description: "List of module identifiers applied to this recipe",
-      items: {
-        type: "string"
-      }
+      items: { type: "string" }
     },
-    name: {
+    image: {
+      description: "Recipe-level hero image(s)",
+      anyOf: [
+        {
+          type: "string",
+          format: "uri"
+        },
+        {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            format: "uri"
+          }
+        }
+      ]
+    },
+    dateAdded: {
       type: "string",
-      description: "Human-readable recipe name"
+      format: "date-time"
+    },
+    metadata: {
+      type: "object",
+      additionalProperties: true,
+      description: "Free-form vendor metadata"
+    },
+    source: {
+      type: "object",
+      properties: {
+        author: { type: "string" },
+        url: { type: "string", format: "uri" },
+        name: { type: "string" },
+        adapted: { type: "boolean" }
+      }
+    },
+    yield: {
+      $ref: "#/definitions/yield"
+    },
+    time: {
+      $ref: "#/definitions/time"
+    },
+    equipment: {
+      type: "array",
+      items: { $ref: "#/definitions/equipment" }
     },
     ingredients: {
       type: "array",
-      description: "Ingredients payload; content is validated by profiles/modules"
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/ingredient" },
+          { $ref: "#/definitions/ingredientSubsection" }
+        ]
+      }
     },
     instructions: {
       type: "array",
-      description: "Instruction payload; content is validated by profiles/modules"
+      items: {
+        anyOf: [
+          { type: "string" },
+          { $ref: "#/definitions/instruction" },
+          { $ref: "#/definitions/instructionSubsection" }
+        ]
+      }
+    },
+    storage: {
+      $ref: "#/definitions/storage"
+    },
+    substitutions: {
+      type: "array",
+      items: { $ref: "#/definitions/substitution" }
     }
   },
-  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" },
-    {
+  definitions: {
+    yield: {
       type: "object",
+      required: ["amount", "unit"],
       properties: {
-        profile: { const: "core" },
-        modules: {
+        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"],
+          description: "Display-friendly unit text; implementations may normalize or canonicalize units separately."
+        }
+      }
+    },
+    scaling: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: {
+          type: "string",
+          enum: ["linear", "discrete", "proportional", "fixed", "bakers_percentage"]
+        },
+        factor: { type: "number" },
+        referenceId: { type: "string" },
+        roundTo: { type: "number" },
+        min: { type: "number" },
+        max: { type: "number" }
+      },
+      if: {
+        properties: { type: { const: "bakers_percentage" } }
+      },
+      then: {
+        required: ["referenceId"]
+      }
+    },
+    ingredient: {
+      type: "object",
+      required: ["item"],
+      properties: {
+        id: { type: "string" },
+        item: { type: "string" },
+        quantity: { $ref: "#/definitions/quantity" },
+        name: { type: "string" },
+        aisle: { type: "string" },
+        prep: { type: "string" },
+        prepAction: { type: "string" },
+        prepActions: {
           type: "array",
           items: { type: "string" },
-          uniqueItems: true,
-          default: []
+          description: "Structured prep verbs (e.g., peel, dice) for mise en place workflows."
         },
-        name: { type: "string", minLength: 1 },
-        ingredients: { type: "array", minItems: 1 },
-        instructions: { type: "array", minItems: 1 }
-      },
-      required: ["profile", "name", "ingredients", "instructions"],
-      additionalProperties: true
+        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" },
+        optional: { type: "boolean" },
+        notes: { type: "string" }
+      }
+    },
+    ingredientSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: { $ref: "#/definitions/ingredient" }
+        }
+      }
+    },
+    equipment: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        id: { type: "string" },
+        name: { type: "string" },
+        required: { type: "boolean" },
+        label: { type: "string" },
+        capacity: { $ref: "#/definitions/quantity" },
+        scalingLimit: { type: "number" },
+        alternatives: {
+          type: "array",
+          items: { type: "string" }
+        }
+      }
+    },
+    instruction: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        id: { type: "string" },
+        text: { type: "string" },
+        image: {
+          type: "string",
+          format: "uri",
+          description: "Optional image that illustrates this instruction"
+        },
+        destination: { type: "string" },
+        dependsOn: {
+          type: "array",
+          items: { type: "string" }
+        },
+        inputs: {
+          type: "array",
+          items: { type: "string" }
+        },
+        timing: {
+          type: "object",
+          required: ["duration", "type"],
+          properties: {
+            duration: {
+              anyOf: [
+                { type: "number" },
+                { type: "string", pattern: "^P" }
+              ],
+              description: "Minutes as a number or ISO8601 duration string"
+            },
+            type: { type: "string", enum: ["active", "passive"] },
+            scaling: { type: "string", enum: ["linear", "fixed", "sqrt"] }
+          }
+        }
+      }
+    },
+    instructionSubsection: {
+      type: "object",
+      required: ["subsection", "items"],
+      properties: {
+        subsection: { type: "string" },
+        items: {
+          type: "array",
+          items: {
+            anyOf: [
+              { type: "string" },
+              { $ref: "#/definitions/instruction" }
+            ]
+          }
+        }
+      }
+    },
+    storage: {
+      type: "object",
+      properties: {
+        roomTemp: { $ref: "#/definitions/storageMethod" },
+        refrigerated: { $ref: "#/definitions/storageMethod" },
+        frozen: {
+          allOf: [
+            { $ref: "#/definitions/storageMethod" },
+            {
+              type: "object",
+              properties: { thawing: { type: "string" } }
+            }
+          ]
+        },
+        reheating: { type: "string" },
+        makeAhead: {
+          type: "array",
+          items: {
+            allOf: [
+              { $ref: "#/definitions/storageMethod" },
+              {
+                type: "object",
+                required: ["component", "storage"],
+                properties: {
+                  component: { type: "string" },
+                  storage: { type: "string", enum: ["roomTemp", "refrigerated", "frozen"] }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    storageMethod: {
+      type: "object",
+      required: ["duration"],
+      properties: {
+        duration: { type: "string", pattern: "^P" },
+        method: { type: "string" },
+        notes: { type: "string" }
+      }
+    },
+    substitution: {
+      type: "object",
+      required: ["ingredient"],
+      properties: {
+        ingredient: { type: "string" },
+        critical: { type: "boolean" },
+        notes: { type: "string" },
+        alternatives: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "ratio"],
+            properties: {
+              name: { type: "string" },
+              ratio: { type: "string" },
+              notes: { type: "string" },
+              impact: { type: "string" },
+              dietary: {
+                type: "array",
+                items: { type: "string" }
+              }
+            }
+          }
+        }
+      }
     }
-  ]
+  }
+};
+
+// src/schemas/recipe/base.schema.json
+var base_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $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",
+  additionalProperties: true,
+  properties: {
+    "@type": {
+      const: "Recipe",
+      description: "Document marker for Soustack recipes"
+    },
+    profile: {
+      type: "string",
+      description: "Profile identifier applied to this recipe"
+    },
+    stacks: {
+      type: "object",
+      description: "Stack declarations as a map: Record<stackName, versionNumber>",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
+    },
+    name: {
+      type: "string",
+      description: "Human-readable recipe name"
+    },
+    ingredients: {
+      type: "array",
+      description: "Ingredients payload; content is validated by profiles/stacks"
+    },
+    instructions: {
+      type: "array",
+      description: "Instruction payload; content is validated by profiles/stacks"
+    }
+  },
+  required: ["@type"]
 };
 
 // src/schemas/recipe/profiles/minimal.schema.json
@@ -1526,7 +2178,7 @@ 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.",
+  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"
@@ -1537,19 +2189,19 @@ var minimal_schema_default = {
         profile: {
           const: "minimal"
         },
-        modules: {
-          type: "array",
-          items: {
-            type: "string",
-            enum: [
-              "attribution@1",
-              "taxonomy@1",
-              "media@1",
-              "nutrition@1",
-              "times@1"
-            ]
+        stacks: {
+          type: "object",
+          additionalProperties: {
+            type: "integer",
+            minimum: 1
           },
-          default: []
+          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",
@@ -1575,23 +2227,304 @@ var minimal_schema_default = {
   ]
 };
 
-// src/schemas/recipe/modules/schedule/1.schema.json
+// 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: {
+        profile: { const: "core" },
+        stacks: {
+          type: "object",
+          additionalProperties: {
+            type: "integer",
+            minimum: 1
+          }
+        },
+        name: { type: "string", minLength: 1 },
+        ingredients: { type: "array", minItems: 1 },
+        instructions: { type: "array", minItems: 1 }
+      },
+      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: {
+        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 }
+      }
+    }
+  ]
+};
+
+// 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"] }
+      ]
+    },
+    instructionSubsectionWithImage: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/instructionSubsection" },
+        {
+          properties: {
+            items: {
+              type: "array",
+              contains: { $ref: "#/definitions/imageInstruction" }
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+
+// 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: {
+        ingredients: {
+          type: "array",
+          items: {
+            anyOf: [
+              { $ref: "#/definitions/quantifiedIngredient" },
+              { $ref: "#/definitions/quantifiedIngredientSubsection" }
+            ]
+          }
+        }
+      }
+    }
+  ],
+  definitions: {
+    quantifiedIngredient: {
+      allOf: [
+        { $ref: "http://soustack.org/schema/v0.3.0#/definitions/ingredient" },
+        { required: ["item", "quantity"] }
+      ]
+    },
+    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: {
+        yield: {
+          allOf: [
+            { $ref: "http://soustack.org/schema/v0.3.0#/definitions/yield" },
+            { properties: { amount: { type: "number", exclusiveMinimum: 0 } } }
+          ]
+        },
+        ingredients: {
+          type: "array",
+          minItems: 1,
+          items: {
+            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",
+                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"] }
+      ]
+    },
+    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/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.",
+  $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: {
-    profile: { type: "string" },
-    modules: {
-      type: "array",
-      items: { type: "string" }
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
-    schedule: {
+    attribution: {
       type: "object",
       properties: {
-        tasks: { type: "array" }
+        url: { type: "string" },
+        author: { type: "string" },
+        datePublished: { type: "string" }
       },
       additionalProperties: false
     }
@@ -1600,32 +2533,33 @@ var schema_default = {
     {
       if: {
         properties: {
-          modules: {
-            type: "array",
-            contains: { const: "schedule@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              attribution: { const: 1 }
+            },
+            required: ["attribution"]
           }
         }
       },
       then: {
-        required: ["schedule", "profile"],
-        properties: {
-          profile: { const: "core" }
-        }
+        required: ["attribution"]
       }
     },
     {
       if: {
-        required: ["schedule"]
+        required: ["attribution"]
       },
       then: {
-        required: ["modules", "profile"],
+        required: ["stacks"],
         properties: {
-          modules: {
-            type: "array",
-            items: { type: "string" },
-            contains: { const: "schedule@1" }
-          },
-          profile: { const: "core" }
+          stacks: {
+            type: "object",
+            properties: {
+              attribution: { const: 1 }
+            },
+            required: ["attribution"]
+          }
         }
       }
     }
@@ -1633,23 +2567,26 @@ var schema_default = {
   additionalProperties: true
 };
 
-// src/schemas/recipe/modules/nutrition/1.schema.json
+// src/schemas/recipe/stacks/media/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.",
+  $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: {
-    modules: {
-      type: "array",
-      items: { type: "string" }
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
-    nutrition: {
+    media: {
       type: "object",
       properties: {
-        calories: { type: "number" },
-        protein_g: { type: "number" }
+        images: { type: "array", items: { type: "string" } },
+        videos: { type: "array", items: { type: "string" } }
       },
       additionalProperties: false
     }
@@ -1658,27 +2595,32 @@ var schema_default2 = {
     {
       if: {
         properties: {
-          modules: {
-            type: "array",
-            contains: { const: "nutrition@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              media: { const: 1 }
+            },
+            required: ["media"]
           }
         }
       },
       then: {
-        required: ["nutrition"]
+        required: ["media"]
       }
     },
     {
       if: {
-        required: ["nutrition"]
+        required: ["media"]
       },
       then: {
-        required: ["modules"],
+        required: ["stacks"],
         properties: {
-          modules: {
-            type: "array",
-            items: { type: "string" },
-            contains: { const: "nutrition@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              media: { const: 1 }
+            },
+            required: ["media"]
           }
         }
       }
@@ -1687,24 +2629,26 @@ var schema_default2 = {
   additionalProperties: true
 };
 
-// src/schemas/recipe/modules/attribution/1.schema.json
+// src/schemas/recipe/stacks/nutrition/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.",
+  $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: {
-    modules: {
-      type: "array",
-      items: { type: "string" }
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
-    attribution: {
+    nutrition: {
       type: "object",
       properties: {
-        url: { type: "string" },
-        author: { type: "string" },
-        datePublished: { type: "string" }
+        calories: { type: "number" },
+        protein_g: { type: "number" }
       },
       additionalProperties: false
     }
@@ -1713,27 +2657,32 @@ var schema_default3 = {
     {
       if: {
         properties: {
-          modules: {
-            type: "array",
-            contains: { const: "attribution@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              nutrition: { const: 1 }
+            },
+            required: ["nutrition"]
           }
         }
       },
       then: {
-        required: ["attribution"]
+        required: ["nutrition"]
       }
     },
     {
       if: {
-        required: ["attribution"]
+        required: ["nutrition"]
       },
       then: {
-        required: ["modules"],
+        required: ["stacks"],
         properties: {
-          modules: {
-            type: "array",
-            items: { type: "string" },
-            contains: { const: "attribution@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              nutrition: { const: 1 }
+            },
+            required: ["nutrition"]
           }
         }
       }
@@ -1742,24 +2691,26 @@ var schema_default3 = {
   additionalProperties: true
 };
 
-// src/schemas/recipe/modules/taxonomy/1.schema.json
+// src/schemas/recipe/stacks/schedule/1.schema.json
 var schema_default4 = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://soustack.org/schemas/recipe/modules/taxonomy/1.schema.json",
-  title: "Soustack Recipe Module: taxonomy v1",
-  description: "Schema for the taxonomy module. Enforces keyword and categorization data when enabled and ensures module declaration accompanies the namespace block.",
+  $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: {
-    modules: {
-      type: "array",
-      items: { type: "string" }
+    profile: { type: "string" },
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
-    taxonomy: {
+    schedule: {
       type: "object",
       properties: {
-        keywords: { type: "array", items: { type: "string" } },
-        category: { type: "string" },
-        cuisine: { type: "string" }
+        tasks: { type: "array" }
       },
       additionalProperties: false
     }
@@ -1768,28 +2719,37 @@ var schema_default4 = {
     {
       if: {
         properties: {
-          modules: {
-            type: "array",
-            contains: { const: "taxonomy@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              schedule: { const: 1 }
+            },
+            required: ["schedule"]
           }
         }
       },
       then: {
-        required: ["taxonomy"]
+        required: ["schedule", "profile"],
+        properties: {
+          profile: { const: "core" }
+        }
       }
     },
     {
       if: {
-        required: ["taxonomy"]
+        required: ["schedule"]
       },
       then: {
-        required: ["modules"],
+        required: ["stacks", "profile"],
         properties: {
-          modules: {
-            type: "array",
-            items: { type: "string" },
-            contains: { const: "taxonomy@1" }
-          }
+          stacks: {
+            type: "object",
+            properties: {
+              schedule: { const: 1 }
+            },
+            required: ["schedule"]
+          },
+          profile: { const: "core" }
         }
       }
     }
@@ -1797,23 +2757,27 @@ var schema_default4 = {
   additionalProperties: true
 };
 
-// src/schemas/recipe/modules/media/1.schema.json
+// src/schemas/recipe/stacks/taxonomy/1.schema.json
 var schema_default5 = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://soustack.org/schemas/recipe/modules/media/1.schema.json",
-  title: "Soustack Recipe Module: media v1",
-  description: "Schema for the media module. Guards media blocks based on module activation and ensures declarations accompany payloads.",
+  $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: {
-    modules: {
-      type: "array",
-      items: { type: "string" }
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
-    media: {
+    taxonomy: {
       type: "object",
       properties: {
-        images: { type: "array", items: { type: "string" } },
-        videos: { type: "array", items: { type: "string" } }
+        keywords: { type: "array", items: { type: "string" } },
+        category: { type: "string" },
+        cuisine: { type: "string" }
       },
       additionalProperties: false
     }
@@ -1822,27 +2786,32 @@ var schema_default5 = {
     {
       if: {
         properties: {
-          modules: {
-            type: "array",
-            contains: { const: "media@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              taxonomy: { const: 1 }
+            },
+            required: ["taxonomy"]
           }
         }
       },
       then: {
-        required: ["media"]
+        required: ["taxonomy"]
       }
     },
     {
       if: {
-        required: ["media"]
+        required: ["taxonomy"]
       },
       then: {
-        required: ["modules"],
+        required: ["stacks"],
         properties: {
-          modules: {
-            type: "array",
-            items: { type: "string" },
-            contains: { const: "media@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              taxonomy: { const: 1 }
+            },
+            required: ["taxonomy"]
           }
         }
       }
@@ -1851,17 +2820,20 @@ var schema_default5 = {
   additionalProperties: true
 };
 
-// src/schemas/recipe/modules/times/1.schema.json
+// src/schemas/recipe/stacks/times/1.schema.json
 var schema_default6 = {
   $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://soustack.org/schemas/recipe/modules/times/1.schema.json",
-  title: "Soustack Recipe Module: times v1",
-  description: "Schema for the times module. Maintains alignment between module declarations and timing payloads.",
+  $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: {
-    modules: {
-      type: "array",
-      items: { type: "string" }
+    stacks: {
+      type: "object",
+      additionalProperties: {
+        type: "integer",
+        minimum: 1
+      }
     },
     times: {
       type: "object",
@@ -1877,9 +2849,12 @@ var schema_default6 = {
     {
       if: {
         properties: {
-          modules: {
-            type: "array",
-            contains: { const: "times@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              times: { const: 1 }
+            },
+            required: ["times"]
           }
         }
       },
@@ -1892,12 +2867,14 @@ var schema_default6 = {
         required: ["times"]
       },
       then: {
-        required: ["modules"],
+        required: ["stacks"],
         properties: {
-          modules: {
-            type: "array",
-            items: { type: "string" },
-            contains: { const: "times@1" }
+          stacks: {
+            type: "object",
+            properties: {
+              times: { const: 1 }
+            },
+            required: ["times"]
           }
         }
       }
@@ -1907,69 +2884,71 @@ var schema_default6 = {
 };
 
 // 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 = {
-  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 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__default.default({ strict: false, allErrors: collectAllErrors });
+  const ajv = new Ajv2020__default.default({
+    strict: false,
+    allErrors: collectAllErrors,
+    validateSchema: false
+    // Don't validate schemas themselves
+  });
   addFormats__default.default(ajv);
-  const addSchemaWithAlias = (schema, alias) => {
-    if (!schema) return;
-    const schemaId = schema.$id || alias;
-    if (schemaId) {
-      ajv.addSchema(schema, schemaId);
-    } else {
-      ajv.addSchema(schema);
-    }
+  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()
   };
-  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)) {
@@ -1983,275 +2962,239 @@ 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;
+function formatAjvError(error) {
+  let path2 = error.instancePath || "/";
+  if (error.keyword === "additionalProperties" && error.params?.additionalProperty) {
+    const extra = error.params.additionalProperty;
+    path2 = `${error.instancePath || ""}/${extra}`.replace(/\/+/g, "/") || "/";
   }
-  return void 0;
+  return {
+    path: path2,
+    keyword: error.keyword,
+    message: error.message || "Validation error"
+  };
 }
-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"
+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, 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);
-      }
+  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 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(",")}`;
+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;
-  if (!profileSchemas[profile]) {
-    throw new Error(`Unknown Soustack profile: ${profile}`);
-  }
-  const schema = {
-    $id: `urn:soustack:recipe:${cacheKey}`,
-    allOf: [
-      { $ref: CANONICAL_BASE_SCHEMA_ID },
-      { $ref: canonicalProfileId(profile) },
-      ...sortedModules.map((moduleId) => ({ $ref: moduleIdToSchemaRef(moduleId) }))
-    ]
+  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
   };
-  const validateFn = context.ajv.compile(schema);
+  const validateFn = context.ajv.compile(composedSchema);
   context.validators.set(cacheKey, validateFn);
   return validateFn;
 }
-function normalizeRecipe(recipe) {
-  const normalized = cloneRecipe(recipe);
-  const warnings = [];
-  normalizeTime(normalized);
-  if (normalized && typeof normalized === "object" && "version" in normalized && !normalized.recipeVersion && typeof normalized.version === "string") {
-    normalized.recipeVersion = normalized.version;
-    warnings.push({ path: "/version", message: "'version' is deprecated; mapped to 'recipeVersion'." });
-  }
-  return { normalized, warnings };
-}
-function normalizeTime(recipe) {
-  const time = recipe?.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;
+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}`
+          }
+        ]
+      };
     }
-  });
-}
-var allowedTopLevelProps = /* @__PURE__ */ new Set([
-  ...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 [];
-  const disallowedKeys = Object.keys(recipe).filter(
-    (key) => !allowedTopLevelProps.has(key) && !key.startsWith("x-")
-  );
-  return disallowedKeys.map((key) => ({
-    path: `/${key}`,
-    keyword: "additionalProperties",
-    message: `Unknown top-level property '${key}' is not allowed by the Soustack spec`
-  }));
-}
-function formatAjvError(error) {
-  let path2 = error.instancePath || "/";
-  if (error.keyword === "additionalProperties" && error.params?.additionalProperty) {
-    const extra = error.params.additionalProperty;
-    path2 = `${error.instancePath || ""}/${extra}`.replace(/\/+/g, "/") || "/";
+    const schemaInput = cloneRecipe(normalized);
+    if (hasSchemaOverride && "$schema" in schemaInput && schemaInput.$schema !== schemaId) {
+      delete schemaInput.$schema;
+    }
+    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)
+    };
   }
-  return {
-    path: path2,
-    keyword: error.keyword,
-    message: error.message || "Validation error"
-  };
-}
-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"
+  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;
       }
-    ];
+    }
   }
-}
-function isInstruction(item) {
-  return item && typeof item === "object" && !Array.isArray(item) && "text" in item;
-}
-function isInstructionSubsection(item) {
-  return item && typeof item === "object" && !Array.isArray(item) && "items" in item && "subsection" in item;
-}
-function checkInstructionGraph(recipe) {
-  const instructions = recipe?.instructions;
-  if (!Array.isArray(instructions)) return [];
-  const instructionIds = /* @__PURE__ */ new Set();
-  const dependencyRefs = [];
-  const collect = (items, basePath) => {
-    items.forEach((item, index) => {
-      const currentPath = `${basePath}/${index}`;
-      if (isInstructionSubsection(item) && Array.isArray(item.items)) {
-        collect(item.items, `${currentPath}/items`);
-        return;
+  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 (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}`
-              });
-            }
-          });
+      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];
         }
       }
-    });
-  };
-  collect(instructions, "/instructions");
-  const errors = [];
-  dependencyRefs.forEach((ref) => {
-    if (!instructionIds.has(ref.toId)) {
-      errors.push({
-        path: ref.path,
-        message: `Instruction dependency references missing id '${ref.toId}'.`
-      });
-    }
-  });
-  const adjacency = /* @__PURE__ */ new Map();
-  dependencyRefs.forEach((ref) => {
-    if (ref.fromId && instructionIds.has(ref.fromId) && instructionIds.has(ref.toId)) {
-      const list = adjacency.get(ref.fromId) ?? [];
-      list.push({ toId: ref.toId, path: ref.path });
-      adjacency.set(ref.fromId, list);
-    }
-  });
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const detectCycles = (nodeId) => {
-    if (visiting.has(nodeId)) return;
-    if (visited.has(nodeId)) return;
-    visiting.add(nodeId);
-    const neighbors = adjacency.get(nodeId) ?? [];
-    neighbors.forEach((edge) => {
-      if (visiting.has(edge.toId)) {
-        errors.push({
-          path: edge.path,
-          message: `Circular dependency detected involving instruction id '${edge.toId}'.`
-        });
-        return;
+      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;
+        }
       }
-      detectCycles(edge.toId);
-    });
-    visiting.delete(nodeId);
-    visited.add(nodeId);
+    }
+  }
+  return {
+    ok: isValid,
+    errors: errors.map(formatAjvError)
   };
-  instructionIds.forEach((id) => detectCycles(id));
-  return errors;
 }
 function validateRecipe(input, options = {}) {
-  const collectAllErrors = options.collectAllErrors ?? true;
-  const context = getContext(collectAllErrors);
-  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 { 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,
+    options.collectAllErrors ?? true,
+    options.schema
+  );
+  const mode = options.mode ?? "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 unknownKeyErrors = detectUnknownTopLevelKeys(normalized);
-  const validationErrors = runAjvValidation(normalized, profile, modules, context);
-  const graphErrors = modules.includes("schedule@1") && validationErrors.length === 0 ? checkInstructionGraph(normalized) : [];
-  const errors = [...unknownKeyErrors, ...validationErrors, ...graphErrors];
+  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
   };
 }
 
 // bin/cli.ts
-var supportedProfiles = ["base", "cookable", "scalable", "quantified", "illustrated", "schedulable"];
+var supportedProfiles = [
+  "base",
+  "equipped",
+  "illustrated",
+  "lite",
+  "prepped",
+  "scalable",
+  "timed"
+];
 async function runCli(argv) {
   const [command, ...args] = argv;
   try {
     switch (command) {
+      case "check":
+        await handleCheck(args);
+        return;
       case "validate":
         await handleValidate(args);
         return;
@@ -2281,23 +3224,50 @@ async function runCli(argv) {
 }
 function printUsage() {
   console.log("Usage:");
-  console.log("  soustack validate <fileOrGlob> [--profile <name>] [--strict] [--json]");
+  console.log("  soustack check <file> --json");
+  console.log(
+    "  soustack validate <fileOrGlob> [--profile <name>] [--force-profile] [--schema-only] [--strict] [--json]"
+  );
   console.log("  soustack convert --from <schemaorg|soustack> --to <schemaorg|soustack> <input> [-o <output>]");
   console.log("  soustack import --url <url> [-o <soustack.json>]");
-  console.log("  soustack test [--profile <name>] [--strict] [--json]");
+  console.log("  soustack test [--profile <name>] [--force-profile] [--schema-only] [--strict] [--json]");
   console.log("  soustack scale <soustack.json> <multiplier>");
   console.log("  soustack scrape <url> -o <soustack.json>");
+  console.log(`
+Profiles: ${supportedProfiles.join(", ")}`);
+}
+async function handleCheck(args) {
+  const { target, json } = parseCheckArgs(args);
+  if (!target) throw new Error("Path to Soustack recipe JSON is required");
+  if (!json) throw new Error("Check usage: check <file> --json");
+  try {
+    const input = readJsonFile(target);
+    const result = validateRecipe(input, { mode: "full", includeNormalized: true });
+    const report = buildConformanceReport(result);
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok) process.exitCode = 1;
+  } catch (error) {
+    const report = buildConformanceReport({
+      ok: false,
+      warnings: [],
+      schemaErrors: [{ path: "/", message: error?.message || "Validation failed" }],
+      conformanceIssues: [],
+      normalizedRecipe: void 0
+    });
+    console.log(JSON.stringify(report, null, 2));
+    process.exitCode = 1;
+  }
 }
 async function handleValidate(args) {
-  const { target, profile, strict, json } = parseValidateArgs(args);
+  const { target, profile, forceProfile, strict, json, mode } = parseValidateArgs(args);
   if (!target) throw new Error("Path or glob to Soustack recipe JSON is required");
   const files = expandTargets(target);
   if (files.length === 0) throw new Error(`No files matched pattern: ${target}`);
-  const results = files.map((file) => validateFile(file, profile));
-  reportValidation(results, { strict, json });
+  const results = files.map((file) => validateFile(file, profile, mode, forceProfile));
+  reportValidation(results, { strict, json});
 }
 async function handleTest(args) {
-  const { profile, strict, json } = parseValidationFlags(args);
+  const { profile, forceProfile, strict, json, mode } = parseValidationFlags(args);
   const cwd = process.cwd();
   const files = glob.globSync("**/*.soustack.json", {
     cwd,
@@ -2309,7 +3279,7 @@ async function handleTest(args) {
     console.log("No *.soustack.json files found in the current repository.");
     return;
   }
-  const results = files.map((file) => validateFile(file, profile));
+  const results = files.map((file) => validateFile(file, profile, mode, forceProfile));
   reportValidation(results, { strict, json, context: "test" });
 }
 async function handleConvert(args) {
@@ -2361,8 +3331,10 @@ async function handleScrape(args) {
 }
 function parseValidateArgs(args) {
   let profile;
+  let forceProfile = false;
   let strict = false;
   let json = false;
+  let mode = "full";
   let target;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -2371,6 +3343,12 @@ function parseValidateArgs(args) {
         profile = normalizeProfile(args[i + 1]);
         i++;
         break;
+      case "--force-profile":
+        forceProfile = true;
+        break;
+      case "--schema-only":
+        mode = "schema";
+        break;
       case "--strict":
         strict = true;
         break;
@@ -2384,11 +3362,26 @@ function parseValidateArgs(args) {
         break;
     }
   }
-  return { profile, strict, json, target };
+  return { profile, forceProfile, strict, json, mode, target };
+}
+function parseCheckArgs(args) {
+  let json = false;
+  let target;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (!arg.startsWith("--") && !target) {
+      target = arg;
+    }
+  }
+  return { target, json };
 }
 function parseValidationFlags(args) {
-  const { profile, strict, json } = parseValidateArgs(args);
-  return { profile, strict, json };
+  const { profile, forceProfile, strict, json, mode } = parseValidateArgs(args);
+  return { profile, forceProfile, strict, json, mode };
 }
 function normalizeProfile(value) {
   if (!value) return void 0;
@@ -2396,7 +3389,7 @@ function normalizeProfile(value) {
   if (supportedProfiles.includes(normalized)) {
     return normalized;
   }
-  throw new Error(`Unknown Soustack profile: ${value}`);
+  throw new Error(`Unknown Soustack profile: ${value}. Supported profiles: ${supportedProfiles.join(", ")}`);
 }
 function parseConvertArgs(args) {
   let from;
@@ -2462,16 +3455,64 @@ function expandTargets(target) {
   const unique = Array.from(new Set(matches.map((match) => path__namespace.resolve(match))));
   return unique;
 }
-function validateFile(file, profile) {
-  const recipe = readJsonFile(file);
-  const result = validateRecipe(recipe, profile ? { profile } : {});
-  return {
-    file,
-    profile,
-    valid: result.valid,
-    warnings: result.warnings,
-    errors: result.errors
-  };
+function validateFile(file, profile, mode = "full", forceProfile = false) {
+  try {
+    const recipe = readJsonFile(file);
+    const { recipe: validationRecipe, mismatchError } = resolveProfileForValidation(recipe, profile, forceProfile);
+    if (mismatchError) {
+      return {
+        file,
+        profile,
+        ok: false,
+        warnings: [],
+        schemaErrors: [mismatchError],
+        conformanceIssues: []
+      };
+    }
+    const result = validateRecipe(validationRecipe, profile ? { profile, mode } : { mode });
+    return {
+      file,
+      profile,
+      ok: result.ok,
+      warnings: result.warnings,
+      schemaErrors: result.schemaErrors,
+      conformanceIssues: result.conformanceIssues
+    };
+  } catch (error) {
+    return {
+      file,
+      profile,
+      ok: false,
+      warnings: [],
+      schemaErrors: [{ path: "/", message: error?.message || "Validation failed", keyword: "error" }],
+      conformanceIssues: []
+    };
+  }
+}
+function resolveProfileForValidation(recipe, profile, forceProfile = false) {
+  if (!profile) return { recipe };
+  if (!recipe || typeof recipe !== "object" || Array.isArray(recipe)) {
+    return { recipe };
+  }
+  const recipeProfileRaw = recipe.profile;
+  const recipeProfile = typeof recipeProfileRaw === "string" ? recipeProfileRaw.toLowerCase() : void 0;
+  if (!recipeProfile) {
+    return { recipe: { ...recipe, profile } };
+  }
+  if (recipeProfile !== profile) {
+    if (!forceProfile) {
+      return {
+        recipe,
+        mismatchError: {
+          path: "/profile",
+          keyword: "profile",
+          message: `Recipe profile "${recipeProfile}" does not match --profile "${profile}". Use --force-profile to override.`
+        }
+      };
+    }
+    return { recipe: { ...recipe, profile } };
+  }
+  return { recipe };
 }
 function reportValidation(results, options) {
   const summary = {
@@ -2487,9 +3528,10 @@ function reportValidation(results, options) {
     return {
       file: path__namespace.relative(process.cwd(), result.file),
       profile: result.profile,
-      valid: result.valid,
+      ok: result.ok,
       warnings: result.warnings,
-      errors: result.errors,
+      schemaErrors: result.schemaErrors,
+      conformanceIssues: result.conformanceIssues,
       passed
     };
   });
@@ -2499,14 +3541,22 @@ function reportValidation(results, options) {
     serializable.forEach((entry) => {
       const prefix = entry.passed ? "\u2705" : "\u274C";
       console.log(`${prefix} ${entry.file}`);
-      if (!entry.passed && entry.errors.length) {
-        entry.errors.forEach((error) => {
+      if (!entry.passed && entry.schemaErrors.length) {
+        console.log("   Schema errors:");
+        entry.schemaErrors.forEach((error) => {
           console.log(`   \u2022 [${error.path}] ${error.message}`);
         });
       }
+      if (!entry.passed && entry.conformanceIssues.length) {
+        console.log("   Conformance issues:");
+        entry.conformanceIssues.forEach((issue) => {
+          console.log(`   \u2022 [${issue.path}] ${issue.message} (${issue.code})`);
+        });
+      }
       if (!entry.passed && options.strict && entry.warnings.length) {
+        console.log("   Warnings:");
         entry.warnings.forEach((warning) => {
-          console.log(`   \u2022 [${warning.path}] ${warning.message} (warning)`);
+          console.log(`   \u2022 ${warning} (warning)`);
         });
       }
     });
@@ -2518,7 +3568,7 @@ function reportValidation(results, options) {
   }
 }
 function isEffectivelyValid(result, strict) {
-  return result.valid && (!strict || result.warnings.length === 0);
+  return result.ok && (!strict || result.warnings.length === 0);
 }
 function readJsonFile(relativePath) {
   const absolutePath = path__namespace.resolve(relativePath);
@@ -2550,6 +3600,52 @@ function writeOutput(data, outputPath) {
   const absolutePath = path__namespace.resolve(outputPath);
   fs__namespace.writeFileSync(absolutePath, serialized, "utf-8");
 }
+function buildConformanceReport(result) {
+  const recipe = result.normalizedRecipe;
+  const level = typeof recipe?.level === "string" ? recipe.level : null;
+  const stacks = normalizeStacksForReport(recipe?.stacks);
+  const schemaErrors = sortSchemaErrors(result.schemaErrors).map((error) => ({
+    path: error.path,
+    keyword: error.keyword ?? null,
+    message: error.message
+  }));
+  const conformanceIssues = sortConformanceIssues(result.conformanceIssues).map((issue) => ({
+    code: issue.code,
+    path: issue.path,
+    severity: issue.severity === "warning" ? "warn" : "error",
+    message: issue.message
+  }));
+  return {
+    ok: result.ok,
+    level,
+    stacks,
+    warnings: result.warnings,
+    schemaErrors,
+    conformanceIssues
+  };
+}
+function normalizeStacksForReport(stacks) {
+  if (!stacks || typeof stacks !== "object" || Array.isArray(stacks)) return {};
+  const entries = Object.entries(stacks).filter(([, value]) => typeof value === "number");
+  entries.sort(([a], [b]) => a.localeCompare(b));
+  return Object.fromEntries(entries);
+}
+function sortSchemaErrors(errors) {
+  return [...errors].sort((left, right) => {
+    const pathCompare = left.path.localeCompare(right.path);
+    if (pathCompare !== 0) return pathCompare;
+    const leftKeyword = left.keyword ?? "";
+    const rightKeyword = right.keyword ?? "";
+    return leftKeyword.localeCompare(rightKeyword);
+  });
+}
+function sortConformanceIssues(issues) {
+  return [...issues].sort((left, right) => {
+    const pathCompare = left.path.localeCompare(right.path);
+    if (pathCompare !== 0) return pathCompare;
+    return left.code.localeCompare(right.code);
+  });
+}
 if (__require.main === module) {
   runCli(process.argv.slice(2)).catch((error) => {
     console.error(`\u274C ${error?.message ?? error}`);