@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.6

package/bin/chunks/chunk-R7YELY3C.js

@@ -0,0 +1,923 @@
+import {
+  KNOWLEDGE_RELEASE
+} from "./chunk-BIEDSEL2.js";
+import {
+  COMPOSITION_LESSON_RELEASE,
+  resolveDesignAuthoring
+} from "./chunk-6H3T46F5.js";
+import {
+  json
+} from "./chunk-T6PE4KN4.js";
+
+// src/agent/reference-fit.ts
+var EXPRESSION_ALIASES = {
+  swiss: ["swiss", "systematic", "international typographic", "modernist"],
+  editorial: ["editorial", "literary", "reading room"],
+  "expressive-type": ["expressive type", "expressive typography", "typographic", "type led", "type-led"],
+  "quiet-luxury": ["quiet luxury", "quiet-luxury", "understated luxury", "refined", "restrained"],
+  documentary: ["documentary", "project first", "project-first"],
+  campaign: ["campaign", "fashion"],
+  hospitality: ["hospitality", "atmospheric", "cinematic"],
+  maximalism: ["maximalism", "maximalist", "collage", "graphic maximalism"],
+  handmade: ["handmade", "illustrative", "hand drawn", "hand-drawn"],
+  industrial: ["industrial", "utilitarian"],
+  technical: ["technical", "product led", "product-led"],
+  retro: ["retro", "nostalgic", "vintage"],
+  athletic: ["athletic", "kinetic"],
+  civic: ["civic", "functional", "task led", "task-led"],
+  "text-first": ["text first", "text-first", "sparse", "minimal"],
+  spatial: ["spatial", "experimental", "immersive"]
+};
+var clean = (s) => s.toLowerCase().replace(/[_-]/g, " ").replace(/\s+/g, " ").trim();
+function expressionSignals(request) {
+  const text = clean(request), families = Object.entries(EXPRESSION_ALIASES).filter(([, terms]) => terms.some((t) => text.includes(clean(t)))).map(([id]) => id);
+  return { requested: request, families, uncertainty: request.trim() && !families.length ? "unsupported-expression" : null };
+}
+var TASK_ALIASES = {
+  "inspect-work": ["inspect work", "evaluate work", "portfolio", "case study", "inspect a specimen", "compare type families"],
+  "evaluate-service": ["evaluate service", "find service", "find specialist", "understand scope"],
+  "compare-options": ["compare options", "compare services", "choose", "compare topics"],
+  "understand-process": ["understand process", "how it works"],
+  "read-deeply": ["read deeply", "read insight", "find article", "find poem", "browse archive", "find film", "find information"],
+  "shop-collection": ["shop collection", "explore collection", "explore a brand and products"],
+  "explore-product": ["explore product", "inspect product", "inspect specification", "inspect specifications", "find practical product answers"],
+  "find-location": ["find location", "plan visit", "find menu", "find event", "find programme", "explore events"],
+  "book-inquiry": ["book inquiry", "book visit", "inquire"],
+  "play-audio": ["play audio", "listen audio"]
+};
+function normalizeTasks(tasks, precise = false) {
+  return [...new Set(tasks.flatMap((t) => {
+    const text = clean(t);
+    const hits = Object.entries(TASK_ALIASES).filter(([, aliases]) => aliases.some((a) => text === a && !(precise && ["explore collection", "find information"].includes(a)))).map(([id]) => id);
+    return hits.length ? hits : [text.replaceAll(" ", "-")];
+  }))].sort();
+}
+function businessContexts(text) {
+  const rules = {
+    "financial-service": /bookkeep|accountant|accounting|insurance|tax|financial|reconciliation/i,
+    "legal-service": /\blaw\b|legal|avocat|dispute resolution|chambers|counsel/i,
+    "creative-practice": /editorial|information design|graphic design|designer|typograph|writer|personal practice|creative studio/i,
+    "project-service": /architect|construction|building|roof|repair|contractor|landscape/i,
+    retail: /shop|retail|carry bag|objects for|wall shelf|collection|clothing|fashion/i,
+    venue: /restaurant|supper|menu|exhibition|museum|venue|hotel|gathering/i,
+    "technical-product": /software|platform|product ui|workflow|interface|component|specification/i
+  };
+  return Object.entries(rules).filter(([, pattern]) => pattern.test(text)).map(([id]) => id);
+}
+var WEAK = /* @__PURE__ */ new Set(["type-content", "real-copy", "process", "sparse-media", "action", "business-relationship", "professional-service", "routes", "content-group"]);
+function fitScore(profile, fitSignals, signals, precise = false) {
+  const tasks = normalizeTasks(signals.visitorTasks || [], precise), expression = signals.expression || expressionSignals(signals.theme || "");
+  const specific = profile.tasks.filter((t) => tasks.includes(t) && t !== "book-inquiry"), action = Number(profile.tasks.includes("book-inquiry") && tasks.includes("book-inquiry"));
+  const styles = profile.expressions.filter((t) => expression.families.includes(t)), context = profile.contexts.filter((t) => signals.contexts?.includes(t));
+  const strong = fitSignals.filter((t) => !WEAK.has(t) && signals.known.includes(t)), generic = fitSignals.filter((t) => WEAK.has(t) && signals.known.includes(t));
+  const taskWeight = { "inspect-work": 24, "evaluate-service": 20, "shop-collection": 24, "find-location": 24, "explore-product": 20, "read-deeply": 12, "understand-process": 8, "compare-options": 8, "play-audio": 24 };
+  const contextConflict = precise && !!signals.contexts?.length && !!profile.contexts.length && !context.length;
+  const components = { task: (precise ? specific.map((t) => taskWeight[t] || 8).sort((a, b) => b - a).slice(0, 3).reduce((sum, n) => sum + n, 0) : Math.min(specific.length, 3) * 12) + action, expression: styles.length ? precise ? 50 : 30 : 0, context: context.length ? precise ? 16 : 10 : contextConflict ? -8 : 0, content: Math.min(strong.length, 2) * (precise ? 1 : 3), generic: Number(generic.length > 0) };
+  const score = Object.values(components).reduce((a, b) => a + b, 0);
+  return { score, components, reasons: [...specific.map((t) => `task:${t}`), ...styles.map((t) => `expression:${t}`), ...context.map((t) => `context:${t}`), ...contextConflict ? ["context:transfer-across-business-contexts"] : [], ...strong.map((t) => `content:${t}`), ...generic.length ? [`generic-bounded:${generic.join(",")}`] : []], supported: !!(specific.length || styles.length || context.length || !precise && strong.length) && (!precise || score >= 20) };
+}
+function essentialAssetGap(minimum, signals) {
+  if (minimum === "product-ui" && !signals.known.includes("product-ui")) return "actual product UI absent";
+  if (["one-image", "multiple-images"].includes(minimum) && !signals.known.includes("approved-image")) return "essential approved image absent";
+  if (minimum === "multiple-images" && !signals.known.includes("multiple-images")) return "multiple approved images absent";
+  return "";
+}
+function complementaryFit(pool, limit, tie, precise = false) {
+  const result = [], remaining = [...pool].sort((a, b) => b.score - a.score || tie(a.id).localeCompare(tie(b.id)));
+  while (remaining.length && result.length < limit) {
+    const near = remaining.filter((r) => r.score >= remaining[0].score - (precise ? 6 : 12));
+    const seen = new Set(result.flatMap((r) => r.profile.contributions)), styles = new Set(result.flatMap((r) => r.profile.expressions));
+    const gain = (r) => Math.min(r.profile.contributions.filter((c) => !seen.has(c)).length, precise ? 2 : Infinity) * 3 + Number(r.profile.expressions.some((s) => !styles.has(s)));
+    near.sort((a, b) => gain(b) - gain(a) || b.score - a.score || tie(a.id).localeCompare(tie(b.id)));
+    const next = near[0];
+    result.push({ ...next, reasons: [...next.reasons, `contribution:${next.profile.contributions.join(",")}`] });
+    remaining.splice(remaining.findIndex((r) => r.id === next.id), 1);
+  }
+  return result;
+}
+
+// src/agent/reference-library.ts
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync, statSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join6, relative as relative4, resolve as resolve5, sep as sep2 } from "node:path";
+
+// src/agent/design-calibration.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { deflateSync } from "node:zlib";
+var CALIBRATION_PACK_VERSION = "v2";
+var PROBE_TOKEN = "2E6BFF";
+var PROBE_RGB = { r: 46, g: 107, b: 255 };
+var ACCURACY_PROBE_PHRASE = "Trusted legal help";
+function crc32(buf) {
+  let c = ~0;
+  for (const byte of buf) {
+    c ^= byte;
+    for (let i = 0; i < 8; i++) c = c >>> 1 ^ 3988292384 & -(c & 1);
+  }
+  return ~c >>> 0;
+}
+function pngChunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length);
+  const body = Buffer.concat([Buffer.from(type), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(body));
+  return Buffer.concat([length, body, crc]);
+}
+function solidPng(r, g, b, size = 24) {
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(size, 0);
+  ihdr.writeUInt32BE(size, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 2;
+  const stride = size * 3 + 1;
+  const raw = Buffer.alloc(stride * size);
+  for (let y = 0; y < size; y++) {
+    const row = y * stride;
+    raw[row] = 0;
+    for (let x = 0; x < size; x++) {
+      const i = row + 1 + x * 3;
+      raw[i] = r;
+      raw[i + 1] = g;
+      raw[i + 2] = b;
+    }
+  }
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", deflateSync(raw)),
+    pngChunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function resolveKernelRoot(siteOrKernel) {
+  const env = (process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL)?.trim();
+  if (env && existsSync(join(calibrationPackDir(env), "manifest.json"))) return resolve(env);
+  let cursor = resolve(siteOrKernel);
+  for (let i = 0; i < 8; i++) {
+    for (const packageName of ["@tryvitris/website-harness", "@tryvitris/harness", "@vitris/harness", "@vitris/kernel"]) {
+      const installed = join(cursor, "node_modules", packageName);
+      if (existsSync(join(calibrationPackDir(installed), "manifest.json")) && existsSync(join(installed, "package.json"))) return installed;
+    }
+    if (existsSync(join(calibrationPackDir(cursor), "manifest.json")) && existsSync(join(cursor, "agent/graph.yaml"))) {
+      return cursor;
+    }
+    const pkgPath = join(cursor, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = json(pkgPath);
+        if (["@tryvitris/website-harness", "@tryvitris/harness", "@vitris/harness", "@vitris/kernel"].includes(pkg.name || "") && existsSync(join(calibrationPackDir(cursor), "manifest.json"))) return cursor;
+        const dep = pkg.dependencies?.["@tryvitris/website-harness"] || pkg.dependencies?.["@tryvitris/harness"] || pkg.dependencies?.["@vitris/harness"] || pkg.dependencies?.["@vitris/kernel"];
+        if (typeof dep === "string" && dep.startsWith("file:")) {
+          const kernel = resolve(cursor, dep.slice("file:".length));
+          if (existsSync(join(calibrationPackDir(kernel), "manifest.json"))) return kernel;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+  return void 0;
+}
+function calibrationPackDir(kernel) {
+  const current = join(resolve(kernel), "design-system/calibration", CALIBRATION_PACK_VERSION);
+  return existsSync(join(current, "manifest.json")) ? current : join(resolve(kernel), "design-system/calibration/v1");
+}
+function loadCalibrationManifest(kernel) {
+  return json(join(calibrationPackDir(kernel), "manifest.json"));
+}
+function calibrationPackHash(kernel) {
+  const dir = calibrationPackDir(kernel);
+  const manifest = loadCalibrationManifest(kernel);
+  const hash2 = createHash("sha256");
+  hash2.update(readFileSync(join(dir, "manifest.json")));
+  for (const record of manifest.records) {
+    hash2.update(record.file);
+    hash2.update(readFileSync(join(dir, record.file)));
+  }
+  return hash2.digest("hex");
+}
+
+// src/agent/composition-context.ts
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/knowledge/composition.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join3, relative as relative2, resolve as resolve3 } from "node:path";
+
+// src/knowledge/pack.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2, relative, resolve as resolve2 } from "node:path";
+function sha256(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function confined(dir, file) {
+  if (!file || file.includes("..") || file.startsWith("/") || /^[A-Za-z]:/.test(file)) return void 0;
+  const target = resolve2(dir, file);
+  const rel = relative(dir, target);
+  if (rel.startsWith("..")) return void 0;
+  return target;
+}
+function knowledgeV2Dir(kernel) {
+  return join2(resolve2(kernel), "design-system", "knowledge", "v2");
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function verifyKnowledgeV2(kernel) {
+  const dir = knowledgeV2Dir(kernel);
+  const errors = [];
+  const manifestPath = join2(dir, "manifest.json");
+  if (!existsSync2(manifestPath)) return ["Missing design-system/knowledge/v2 pack"];
+  const manifest = readJson(manifestPath);
+  if (!manifest || manifest.schemaVersion !== 1) errors.push("v2 manifest schema mismatch");
+  if (manifest && manifest.knowledgeRelease !== KNOWLEDGE_RELEASE) errors.push("v2 release mismatch");
+  if (manifest && manifest.labeledPreferenceData !== false) errors.push("v2 pack must not claim labeled preference data");
+  for (const file of manifest?.files || []) {
+    const target = confined(dir, file.path);
+    if (!target || !existsSync2(target)) errors.push(`Missing or unconfined v2 file: ${file.path}`);
+    else if (sha256(readFileSync2(target)) !== file.sha256) errors.push(`v2 hash mismatch: ${file.path}`);
+  }
+  return errors;
+}
+function loadKnowledgeV2(siteOrKernel) {
+  const kernel = resolveKernelRoot(siteOrKernel);
+  if (!kernel) return void 0;
+  const dir = knowledgeV2Dir(kernel);
+  const errors = verifyKnowledgeV2(kernel);
+  const siteConfig = readJson(join2(resolve2(siteOrKernel), "site.json"));
+  if (siteConfig?.knowledgeRelease && siteConfig.knowledgeRelease !== KNOWLEDGE_RELEASE) {
+    errors.push(`Site pins knowledge release ${siteConfig.knowledgeRelease}; installed kernel provides ${KNOWLEDGE_RELEASE}. Review and upgrade explicitly.`);
+  }
+  const sources = readJson(join2(dir, "sources.json")) || [];
+  const requirements = readJson(join2(dir, "requirements.json")) || [];
+  const extensions = readJson(join2(dir, "lesson-extensions.json")) || [];
+  const replacements = readJson(join2(dir, "replacements.json")) || [];
+  const assets = readJson(join2(dir, "assets.json")) || [];
+  for (const source of sources) {
+    if (sha256(source.summary) !== source.summarySha256) errors.push(`Source summary hash mismatch: ${source.id}`);
+    if (source.reviewStatus === "live-checked" && !source.lastReviewed) errors.push(`Live-checked source missing review date: ${source.id}`);
+  }
+  return { kernel, release: KNOWLEDGE_RELEASE, sources, requirements, extensions, replacements, assets, errors };
+}
+function lessonExtension(pack, id) {
+  return pack?.extensions.find((item) => item.id === id);
+}
+function coverageReport(pack) {
+  const missingClassification = pack.requirements.filter((item) => !item.authorityClass || !item.implementationStatus || item.authorityIds.length === 0).map((item) => item.id);
+  return {
+    release: pack.release,
+    requirements: pack.requirements.map((item) => ({
+      id: item.id,
+      authorityClass: item.authorityClass,
+      implementationStatus: item.implementationStatus,
+      verifierId: item.verifierId
+    })),
+    missingClassification
+  };
+}
+
+// src/knowledge/composition.ts
+var sha = (bytes) => createHash3("sha256").update(bytes).digest("hex");
+var hex = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+var unique = (values) => new Set(values).size === values.length;
+function confined2(dir, path) {
+  if (!path || path.includes("..") || path.startsWith("/") || path.includes("\\") || /^[A-Za-z]:/.test(path)) throw new Error(`Unconfined composition pack path: ${path}`);
+  const target = resolve3(dir, path);
+  if (relative2(dir, target).startsWith("..")) throw new Error(`Unconfined composition pack path: ${path}`);
+  for (let cursor = target; cursor !== dir; cursor = dirname2(cursor)) if (existsSync3(cursor) && lstatSync(cursor).isSymbolicLink()) throw new Error(`Symlink in composition pack path: ${path}`);
+  return target;
+}
+function object(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid ${label}`);
+  return value;
+}
+function strings(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) throw new Error(`Invalid ${label}`);
+  return value;
+}
+function parsed(bytes, label) {
+  try {
+    return object(JSON.parse(new TextDecoder().decode(bytes)), label);
+  } catch {
+    throw new Error(`Invalid composition pack JSON: ${label}`);
+  }
+}
+function loadCompositionPack(siteOrKernel, requestedRelease = COMPOSITION_LESSON_RELEASE) {
+  if (requestedRelease !== COMPOSITION_LESSON_RELEASE) throw new Error(`Unknown composition lesson release ${requestedRelease}`);
+  const kernel = resolveKernelRoot(siteOrKernel);
+  if (!kernel) throw new Error("Installed harness root is unavailable for composition lessons");
+  const dir = join3(kernel, "design-system/knowledge/v3");
+  const manifestPath = join3(dir, "manifest.json");
+  if (!existsSync3(manifestPath)) throw new Error(`Missing composition lesson release ${requestedRelease}`);
+  const manifestBytes = readFileSync3(manifestPath);
+  const manifest = parsed(manifestBytes, "manifest");
+  if (manifest.schemaVersion !== 1 || manifest.lessonRelease !== requestedRelease || manifest.standardsRelease !== KNOWLEDGE_RELEASE || manifest.labeledPreferenceData !== false) throw new Error("Composition manifest version or dependency mismatch");
+  const v2Errors = verifyKnowledgeV2(kernel);
+  if (v2Errors.length) throw new Error(`Composition standards dependency invalid: ${v2Errors.join("; ")}`);
+  const requirements = new Set(loadKnowledgeV2(kernel)?.requirements.map((item) => item.id) || []);
+  if (!Array.isArray(manifest.files)) throw new Error("Composition manifest has no files");
+  const bytes = /* @__PURE__ */ new Map();
+  for (const entry of manifest.files) {
+    const file = object(entry, "manifest file");
+    if (typeof file.path !== "string" || !hex(file.sha256)) throw new Error("Invalid composition manifest file entry");
+    if (bytes.has(file.path)) throw new Error(`Duplicate composition file ${file.path}`);
+    const target = confined2(dir, file.path);
+    if (!existsSync3(target)) throw new Error(`Missing composition file ${file.path}`);
+    const content = readFileSync3(target);
+    if (sha(content) !== file.sha256) throw new Error(`Composition hash mismatch: ${file.path}`);
+    bytes.set(file.path, content);
+  }
+  const read3 = (path) => {
+    const content = bytes.get(path);
+    if (!content) throw new Error(`Composition file not in verified manifest: ${path}`);
+    return content;
+  };
+  const catalog = parsed(read3("catalog.json"), "catalog");
+  const examplesFile = parsed(read3("examples/catalog.json"), "examples catalog");
+  const sourcesFile = parsed(read3("sources.json"), "sources");
+  if (catalog.schemaVersion !== 1 || catalog.lessonRelease !== requestedRelease || examplesFile.schemaVersion !== 1 || examplesFile.lessonRelease !== requestedRelease) throw new Error("Composition catalog release mismatch");
+  if (!Array.isArray(catalog.lessons) || catalog.lessons.length !== 24 || !Array.isArray(examplesFile.examples) || !Array.isArray(sourcesFile.sources)) throw new Error("Composition catalog count or shape mismatch");
+  const sources = sourcesFile.sources;
+  const sourceIds = new Set(sources.map((item) => item.id));
+  if (!unique([...sourceIds]) || sourceIds.size !== sources.length) throw new Error("Duplicate composition source ID");
+  const lessons = catalog.lessons;
+  if (!unique(lessons.map((item) => item.id))) throw new Error("Duplicate composition lesson ID");
+  const examples = examplesFile.examples;
+  if (!unique(examples.map((item) => item.id))) throw new Error("Duplicate composition example ID");
+  const exampleMap = new Map(examples.map((item) => [item.id, item]));
+  const usedExamples = /* @__PURE__ */ new Set();
+  for (const lesson of lessons) {
+    if (!/^cmp-[a-z0-9-]+$/.test(lesson.id) || lesson.version !== 1 || lesson.release !== requestedRelease || !lesson.title?.trim() || !lesson.summary?.trim() || !lesson.principle?.trim() || !lesson.relationshipGroup?.trim()) throw new Error(`Invalid composition lesson ${lesson.id}`);
+    for (const key of ["scope", "tasks", "stages", "relationships", "sourceIds", "requirementIds", "demonstrationIds", "reviewProbeIds"]) strings(lesson[key], `${lesson.id}.${key}`);
+    if (!lesson.scope.every((item) => ["element", "section", "page", "site"].includes(item))) throw new Error(`Invalid scope for ${lesson.id}`);
+    const applicability = object(lesson.applicability, `${lesson.id}.applicability`);
+    strings(applicability.positiveSignals, `${lesson.id}.positiveSignals`);
+    strings(applicability.exclusions, `${lesson.id}.exclusions`);
+    if (typeof applicability.uncertainty !== "string" || !applicability.uncertainty.trim()) throw new Error(`Missing uncertainty for ${lesson.id}`);
+    if (!Array.isArray(lesson.evidenceNeeds)) throw new Error(`Invalid evidence needs for ${lesson.id}`);
+    for (const need of lesson.evidenceNeeds) if (!["fact", "media", "route", "interaction-model"].includes(need.kind) || typeof need.mandatory !== "boolean" || need.minimum !== void 0 && (!Number.isInteger(need.minimum) || need.minimum < 0)) throw new Error(`Invalid evidence need for ${lesson.id}`);
+    if (!hex(lesson.contentHash) || sha(read3(lesson.bodyPath)) !== lesson.contentHash) throw new Error(`Body hash mismatch for ${lesson.id}`);
+    for (const id of lesson.sourceIds) if (!sourceIds.has(id)) throw new Error(`Missing source ${id} for ${lesson.id}`);
+    for (const id of lesson.requirementIds) if (!requirements.has(id)) throw new Error(`Missing v2 requirement ${id} for ${lesson.id}`);
+    if (lesson.demonstrationIds.length !== 3) throw new Error(`Lesson ${lesson.id} needs three contrasting scenario records`);
+    const roles = lesson.demonstrationIds.map((id) => {
+      const example = exampleMap.get(id);
+      usedExamples.add(id);
+      if (!example || example.lessonId !== lesson.id || !hex(example.sourceHash) || sha(example.scenario) !== example.sourceHash) throw new Error(`Invalid example ${id} for ${lesson.id}`);
+      if (example.fixturePath) read3(example.fixturePath);
+      if (example.inspectionStatus === "inspected" && (!example.fixturePath || !example.captureHandles.length)) throw new Error(`Example ${id} claims inspection without captured source`);
+      return example.role;
+    });
+    if (!unique(roles) || !roles.includes("application-a") || !roles.includes("application-b") || !roles.includes("counterexample")) throw new Error(`Inconsistent example roles for ${lesson.id}`);
+  }
+  if (usedExamples.size !== examples.length) throw new Error("Orphan composition example record");
+  return { kernel, release: requestedRelease, manifestHash: sha(manifestBytes), lessons, examples, sources, body: (id) => new TextDecoder().decode(read3(lessons.find((item) => item.id === id)?.bodyPath || "")) };
+}
+
+// src/agent/composition-context.ts
+var COMPOSITION_SELECTOR_VERSION = "composition-selector-1";
+var sha2 = (value) => createHash4("sha256").update(value).digest("hex");
+var read = (root, path) => {
+  const file = join4(root, path);
+  if (!existsSync4(file)) return void 0;
+  return JSON.parse(readFileSync4(file, "utf8"));
+};
+function compositionSignalsFromSite(root, page) {
+  const narrative = read(root, "onboarding/narrative-brief.json");
+  const media = read(root, "onboarding/media-inventory.json");
+  const story = read(root, "onboarding/storyboard.json");
+  const direction = read(root, "onboarding/direction.json");
+  const planned = page ? story?.pages.find((item) => item.path === page) : void 0;
+  const texts = [
+    ...(narrative?.visitorQuestions || []).map((item) => ({ text: item.question, origin: `narrative:visitor-question:${item.id}` })),
+    ...(narrative?.designOpportunities || []).map((item) => ({ text: `${item.visitorNeed} ${item.presentationOpportunity}`, origin: `narrative:opportunity:${item.id}` })),
+    ...(planned?.sections || []).map((item) => ({ text: `${item.question} ${item.purpose} ${item.message}`, origin: `storyboard:${page}#${item.id}` })),
+    ...direction?.centralIdea ? [{ text: direction.centralIdea, origin: "direction:centralIdea" }] : []
+  ];
+  const patterns = {
+    "business-relationship": /work|service|process|result|outcome|detail/i,
+    "content-group": /group|related|detail|scope|caption|project|service/i,
+    priority: /urgent|important|primary|first|priority|main/i,
+    alignment: /compare|column|measure|specification|metadata/i,
+    "page-sequence": /process|sequence|journey|step|next|before|after/i,
+    "type-content": /explain|read|story|statement|editorial|guide/i,
+    "real-copy": /explain|detail|qualify|describe|scope|information/i,
+    "approved-image": /image|photo|project|product|visual/i,
+    "multiple-images": /sequence|gallery|portfolio|before and after/i,
+    proof: /evidence|proof|credential|case|review|testimonial|result/i,
+    collection: /services|projects|options|catalog|list|directory/i,
+    comparison: /compare|choose|which|versus|difference|options/i,
+    process: /process|step|prepare|how it works|responsib/i,
+    "sparse-media": /text|document|checklist|scope|ledger/i,
+    routes: /navigation|find|route|browse|pages/i,
+    action: /contact|inquire|book|call|visit|estimate|quote/i,
+    "local-facts": /address|hours|directions|parking|visit|location|service area/i,
+    identity: /identity|brand|motif|material|character/i,
+    responsive: /mobile|narrow|responsive|reflow/i,
+    "optional-detail": /details|optional|expand|technical|specifications/i,
+    "state-change": /motion|transition|animation|change|progress/i,
+    "interaction-model": /interact|select|filter|slider|compare/i,
+    "uncertain-choice": /alternative|uncertain|direction|choose/i
+  };
+  const signals = Object.entries(patterns).map(([id, pattern]) => {
+    const match = texts.find((item) => pattern.test(item.text));
+    return { id, state: match ? "known" : "unknown", origin: match?.origin || "not-established" };
+  });
+  if (media) {
+    const usable = media.assets.filter((item) => item.inspected && item.disposition === "use");
+    const images = usable.filter((item) => item.kind !== "video");
+    const set = (id, state) => {
+      const index = signals.findIndex((item) => item.id === id);
+      signals[index] = { id, state, origin: "onboarding/media-inventory.json:inspected-use" };
+    };
+    set("approved-image", images.length ? "known" : "absent");
+    set("multiple-images", images.length >= 2 ? "known" : "absent");
+    set("sparse-media", images.length <= 1 ? "known" : "absent");
+  }
+  if (story) {
+    const paths = story.pages.map((item) => item.path);
+    signals[signals.findIndex((item) => item.id === "routes")] = { id: "routes", state: paths.length > 1 ? "known" : "absent", origin: "onboarding/storyboard.json:pages" };
+  }
+  return signals;
+}
+function selectCompositionLessons(input) {
+  const known = new Set(input.signals.filter((item) => item.state === "known").map((item) => item.id));
+  const absent = new Set(input.signals.filter((item) => item.state === "absent").map((item) => item.id));
+  const eligible = [], excluded = [];
+  for (const lesson of input.pack.lessons) {
+    if (!lesson.stages.includes(input.stage)) {
+      excluded.push({ id: lesson.id, reason: "stage" });
+      continue;
+    }
+    const impossible = lesson.evidenceNeeds.find((item) => item.mandatory && item.kind === "media" && absent.has("approved-image"));
+    if (impossible) {
+      excluded.push({ id: lesson.id, reason: "required approved media absent" });
+      continue;
+    }
+    const hits = lesson.applicability.positiveSignals.filter((item) => known.has(item));
+    if (!hits.length) {
+      excluded.push({ id: lesson.id, reason: "no established positive signal; available for discovery" });
+      continue;
+    }
+    eligible.push({ id: lesson.id, score: hits.reduce((total, item) => total + 2 + (input.page && input.signals.find((signal) => signal.id === item)?.origin.startsWith(`storyboard:${input.page}#`) ? 3 : 0), 0), reasons: hits.map((item) => `${item}: ${input.signals.find((signal) => signal.id === item)?.origin}`) });
+  }
+  eligible.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  const chosen = [], seenGroups = /* @__PURE__ */ new Set();
+  for (const candidate of eligible) {
+    const lesson = input.pack.lessons.find((item) => item.id === candidate.id);
+    if (chosen.length >= (input.limit ?? 4)) break;
+    if (seenGroups.has(lesson.relationshipGroup) && eligible.some((other) => other.score === candidate.score && !seenGroups.has(input.pack.lessons.find((item) => item.id === other.id).relationshipGroup))) continue;
+    chosen.push(lesson);
+    seenGroups.add(lesson.relationshipGroup);
+  }
+  const ties = [...new Set(eligible.map((item) => item.score))].map((score) => ({ score, ids: eligible.filter((item) => item.score === score).map((item) => item.id) })).filter((item) => item.ids.length > 1);
+  return {
+    schemaVersion: 1,
+    selectorVersion: COMPOSITION_SELECTOR_VERSION,
+    stage: input.stage,
+    page: input.page || null,
+    policyHash: input.policyHash,
+    manifestHash: input.pack.manifestHash,
+    inputSignalHash: sha2(JSON.stringify(input.signals)),
+    signals: input.signals,
+    eligible,
+    excluded,
+    selected: chosen.map((item) => ({ id: item.id, version: item.version, contentHash: item.contentHash, bodyHash: item.contentHash, summary: item.summary, expansionHandle: `composition:${item.id}@${item.version}`, reason: eligible.find((candidate) => candidate.id === item.id).reasons.join("; ") })),
+    alternatives: eligible.filter((item) => !chosen.some((lesson) => lesson.id === item.id)).map((item) => {
+      const lesson = input.pack.lessons.find((entry) => entry.id === item.id);
+      return { id: lesson.id, summary: lesson.summary, expansionHandle: `composition:${lesson.id}@${lesson.version}` };
+    }),
+    ties
+  };
+}
+function compositionContextForStage(root, stage, page, limit) {
+  const policy = resolveDesignAuthoring(root);
+  if (policy.mode !== "composition-v1") return void 0;
+  const pack = loadCompositionPack(root, policy.lessonRelease);
+  const receipt = selectCompositionLessons({ pack, stage, page, signals: compositionSignalsFromSite(root, page), policyHash: policy.hash, limit });
+  return { policy, pack, receipt };
+}
+
+// src/agent/reference-studies.ts
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { isAbsolute, join as join5, relative as relative3, resolve as resolve4, sep } from "node:path";
+var hash = (v) => createHash5("sha256").update(v).digest("hex");
+function confined3(base, path) {
+  const target = resolve4(base, path), rel = relative3(base, target);
+  if (!rel || isAbsolute(path) || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) throw new Error(`Study path escapes release: ${path}`);
+  return target;
+}
+function loadReferenceStudies(kernel, release = "2026-10-05.1") {
+  if (!["2026-10-05.1", "2026-10-06.1", "2026-10-06.2"].includes(release)) throw new Error(`Unsupported original study release: ${release}`);
+  const dataRoot = process.env.VITRIS_REFERENCE_DATA ? resolve4(process.env.VITRIS_REFERENCE_DATA) : kernel;
+  const base = join5(dataRoot, release === "2026-10-05.1" ? "design-system/compositions/v2" : release === "2026-10-06.1" ? "design-system/compositions/v3" : "design-system/compositions/v4"), manifestPath = join5(base, "manifest.json");
+  if (!existsSync5(manifestPath)) throw new Error("Original reference study release unavailable. Corrected teaching releases are optional data; set VITRIS_REFERENCE_DATA to the verified teaching bundle root (see docs/DISTRIBUTION.md).");
+  const bytes = readFileSync5(manifestPath), manifest = JSON.parse(bytes.toString());
+  if (manifest.schemaVersion !== 1 || manifest.release !== release || manifest.labeledPreferenceData !== false || !Array.isArray(manifest.files)) throw new Error("Unsupported original study manifest");
+  const readPinned = (pin) => {
+    const path = confined3(base, pin.path);
+    if (!existsSync5(path) || hash(readFileSync5(path)) !== pin.sha256) throw new Error(`Missing or changed original study file: ${pin.path}`);
+    return readFileSync5(path);
+  };
+  const catalog = JSON.parse(readPinned(manifest.catalog).toString());
+  if (catalog.schemaVersion !== 1 || catalog.release !== manifest.release || !Array.isArray(catalog.studies)) throw new Error("Unsupported original study catalog");
+  const pins = new Map(manifest.files.map((pin) => [pin.path, pin]));
+  if (pins.size !== manifest.files.length) throw new Error("Duplicate original study file pins");
+  for (const pin of manifest.files) readPinned(pin);
+  const ids = /* @__PURE__ */ new Set();
+  for (const study of catalog.studies) {
+    if (study.motionTags !== void 0 && (!Array.isArray(study.motionTags) || study.motionTags.some((t) => typeof t !== "string" || !t.trim()))) throw new Error(`Invalid motion study tags: ${study.id}`);
+    for (const evidence of study.temporalEvidence || []) {
+      if (!evidence.route || !evidence.observation?.trim() || !["agent", "human"].includes(evidence.assessor) || !/^[a-f0-9]{64}$/.test(evidence.scenarioHash) || !/^[a-f0-9]{64}$/.test(evidence.sourceHash) || pins.get(evidence.recording?.path)?.sha256 !== evidence.recording?.sha256) throw new Error(`Unverified original motion recording: ${study.id}`);
+    }
+    if (!/^[a-z0-9-]+$/.test(study.id) || ids.has(study.id) || !Number.isInteger(study.revision) || study.revision < 1 || study.brief?.fictional !== true || study.humanPreference !== null) throw new Error(`Invalid original study contract: ${study.id}`);
+    ids.add(study.id);
+    if (!study.organizingIdea || !study.provenance?.rights || !study.lessonIds?.length || !Array.isArray(study.renderEvidence)) throw new Error(`Incomplete original study: ${study.id}`);
+    confined3(base, study.sourcePath);
+    if (!pins.has(`${study.sourcePath}/study.json`) || !pins.has(`${study.sourcePath}/pages/index.html`) || !pins.has(`${study.sourcePath}/pages/detail/index.html`)) throw new Error(`Unpinned original study source: ${study.id}`);
+    for (const width of [1440, 390]) for (const route of ["/", "/detail"]) if (!study.renderEvidence.some((v) => v.route === route && v.viewport.width === width)) throw new Error(`Missing original study view: ${study.id}/${route}/${width}`);
+    for (const view of study.renderEvidence) {
+      if (pins.get(view.preview.path)?.sha256 !== view.preview.sha256 || !view.visualReview?.reviewedAt) throw new Error(`Unverified original preview: ${study.id}`);
+      if (view.fullPreview && pins.get(view.fullPreview.path)?.sha256 !== view.fullPreview.sha256) throw new Error(`Unverified full original preview: ${study.id}`);
+    }
+  }
+  const lessons = new Set(loadCompositionPack(kernel).lessons.map((l) => l.id));
+  for (const study of catalog.studies) if (study.lessonIds.some((id) => !lessons.has(id))) throw new Error(`Missing original study lesson link: ${study.id}`);
+  return { base, manifest, manifestHash: hash(bytes), catalog, pins };
+}
+function referenceStudyExpansions(kernel, signals, references, accepted, release = "2026-10-05.1") {
+  const pack = loadReferenceStudies(kernel, release);
+  const legacyRanked = () => pack.catalog.studies.filter((s) => s.renderEvidence.length >= 4 && s.fitSignals.some((f) => signals.known.includes(f)) && (s.assetMinimum === "none" || (s.assetMinimum === "product-ui" ? signals.known.includes("product-ui") : signals.known.includes("approved-image"))) && (s.assetMinimum !== "multiple-images" || signals.known.includes("multiple-images"))).map((s) => ({ study: s, score: s.fitSignals.filter((f) => signals.known.includes(f)).length * 3 + Number(s.referenceIds.some((id) => references.includes(id))) })).sort((a, b) => b.score - a.score || hash(`${JSON.stringify(signals)}:${a.study.id}`).localeCompare(hash(`${JSON.stringify(signals)}:${b.study.id}`)));
+  const excluded = [];
+  const correctedRanked = () => pack.catalog.studies.flatMap((study) => {
+    if (!study.selectionProfile) throw new Error("Corrected study lacks normalized selection profile: " + study.id);
+    const profile = study.selectionProfile, interpretation = profile.interpretation;
+    const gap = essentialAssetGap(interpretation?.assetMinimum || study.assetMinimum, signals);
+    if (gap || study.renderEvidence.length < 4) {
+      excluded.push({ id: study.id, reason: gap || "missing preview evidence" });
+      return [];
+    }
+    const fit = fitScore(profile, study.fitSignals, signals, release === "2026-10-06.2");
+    if (!fit.supported) {
+      excluded.push({ id: study.id, reason: "no specific task, expression or context fit" });
+      return [];
+    }
+    return [{ id: study.id, study, profile, ...fit }];
+  }).sort((a, b) => b.score - a.score || hash(JSON.stringify(signals) + a.id).localeCompare(hash(JSON.stringify(signals) + b.id)));
+  const correctedPool = release === "2026-10-05.1" ? void 0 : correctedRanked();
+  const ranked = release === "2026-10-05.1" ? legacyRanked() : correctedPool;
+  if (accepted && new Set(accepted.map((s) => s.id)).size !== accepted.length) throw new Error("Duplicate accepted original study IDs");
+  const selected = accepted ? accepted.map((s) => {
+    const match = ranked.find((r) => r.study.id === s.id && r.study.revision === s.revision);
+    if (!match) throw new Error(`Accepted original study unavailable/ineligible: ${s.id}`);
+    return match;
+  }) : release === "2026-10-05.1" ? ranked.slice(0, 2) : complementaryFit(correctedPool, 2, (id) => hash(JSON.stringify(signals) + id), release === "2026-10-06.2");
+  const expansions = selected.map(({ study, score }) => {
+    const source = [...pack.pins].filter(([path]) => path.startsWith(`${study.sourcePath}/`)).map(([path, pin]) => ({ ...pin, absolutePath: confined3(pack.base, path) }));
+    const previews = study.renderEvidence.map((v) => ({ ...v, absolutePath: confined3(pack.base, v.preview.path) }));
+    const text = JSON.stringify({ boundary: "Original fictional teaching only. Inspect homepage/interior at both widths. Adapt relationships; do not import demo facts into customer inventories.", manifestHash: pack.manifestHash, fitScore: score, study, source, previews }, null, 2);
+    return { id: `reference-study-${study.id}-r${study.revision}`, hash: hash(text), chars: text.length, text };
+  });
+  const gaps = [];
+  if (release !== "2026-10-05.1") {
+    if (!selected.length) gaps.push("original-fit-gap: establish specific tasks/assets or author a suitable original lesson");
+    const requested = signals.expression?.families || [];
+    if (signals.theme?.trim() && (!requested.length || !selected.some((s) => s.study.selectionProfile?.expressions.some((e) => requested.includes(e))))) gaps.push("original-expression-gap: requested expression lacks an eligible selected interpretation; inspect a suitable source or explicitly justify an adaptation");
+  }
+  return { pack, excluded, gaps, selected: selected.map(({ study, score }) => ({ id: study.id, revision: study.revision, score, reasons: study.selectionProfile ? fitScore(study.selectionProfile, study.fitSignals, signals, release === "2026-10-06.2").reasons : [], handle: `reference-study-${study.id}-r${study.revision}`, idea: study.organizingIdea })), expansions };
+}
+
+// src/agent/reference-library.ts
+var REFERENCE_RELEASE = "2026-10-05.1";
+var REFERENCE_SELECTOR = "fit-complementarity-3";
+var INITIAL_CORRECTED_REFERENCE_RELEASE = "2026-10-06.1";
+var CORRECTED_REFERENCE_RELEASE = "2026-10-06.2";
+var CORRECTED_REFERENCE_SELECTOR = "task-expression-complementarity-2";
+var referenceSelectorVersion = (release) => release === REFERENCE_RELEASE ? REFERENCE_SELECTOR : release === INITIAL_CORRECTED_REFERENCE_RELEASE ? "task-expression-complementarity-1" : CORRECTED_REFERENCE_SELECTOR;
+var referenceReleaseDirectory = (release = REFERENCE_RELEASE) => {
+  if (release === REFERENCE_RELEASE) return "v1";
+  if (release === INITIAL_CORRECTED_REFERENCE_RELEASE) return "v2";
+  if (release === CORRECTED_REFERENCE_RELEASE) return "v3";
+  throw new Error(`Unsupported reference release: ${release}`);
+};
+var REFERENCE_FAMILIES = ["swiss", "editorial", "expressive-type", "quiet-luxury", "documentary", "campaign", "hospitality", "maximalism", "handmade", "industrial", "technical", "retro", "athletic", "civic", "text-first", "spatial"];
+var referenceHash = (value) => createHash6("sha256").update(value).digest("hex");
+var read2 = (path) => JSON.parse(readFileSync6(path, "utf8"));
+function confinedReferencePath(base, path) {
+  const target = resolve5(base, path), rel = relative4(resolve5(base), target);
+  if (isAbsolute2(path) || !rel || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) throw new Error(`Reference path escapes release: ${path}`);
+  return target;
+}
+function referencePolicy(root) {
+  const launch = existsSync6(join6(root, "launch.json")) ? read2(join6(root, "launch.json")) : {};
+  const raw = launch.designReferences;
+  if (raw === void 0) return void 0;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("designReferences must be an object");
+  const config = raw;
+  if (![REFERENCE_RELEASE, INITIAL_CORRECTED_REFERENCE_RELEASE, CORRECTED_REFERENCE_RELEASE].includes(String(config.release)) || config.mode !== "lessons") throw new Error(`Unsupported designReferences; use mode lessons, release ${REFERENCE_RELEASE}`);
+  if (config.manifestHash !== void 0 && (typeof config.manifestHash !== "string" || !/^[a-f0-9]{64}$/.test(config.manifestHash))) throw new Error("Invalid reference manifestHash");
+  if (config.teachingManifestHash !== void 0 && (typeof config.teachingManifestHash !== "string" || !/^[a-f0-9]{64}$/.test(config.teachingManifestHash))) throw new Error("Invalid reference teachingManifestHash");
+  return { release: config.release, mode: "lessons", manifestHash: config.manifestHash, teachingManifestHash: config.teachingManifestHash, hash: referenceHash(JSON.stringify(config)) };
+}
+function validateReferenceCatalog(catalog) {
+  const errors = [], ids = /* @__PURE__ */ new Set(), urls = /* @__PURE__ */ new Set();
+  if (catalog.schemaVersion !== 1 || ![REFERENCE_RELEASE, INITIAL_CORRECTED_REFERENCE_RELEASE, CORRECTED_REFERENCE_RELEASE].includes(catalog.release) || !Array.isArray(catalog.records)) return ["Unsupported reference catalog"];
+  for (const r of catalog.records) {
+    if (!r || typeof r !== "object") {
+      errors.push("Reference must be an object");
+      continue;
+    }
+    const fail = (message) => errors.push(`${r.id || "missing-id"}: ${message}`);
+    if (catalog.release !== REFERENCE_RELEASE) {
+      const p = r.selectionProfile, e = r.visualEvidence;
+      if (!p || [p.tasks, p.expressions, p.contexts, p.contributions].some((a) => !Array.isArray(a) || a.some((v) => typeof v !== "string" || !v.trim())) || !p.contributions.length || p.expressions.some((v) => !REFERENCE_FAMILIES.includes(v))) fail("invalid normalized selection profile");
+      if (!e || !["legacy-observation", "live-only", "retained-capture", "accessible-session"].includes(e.kind) || e.sourceRevision !== r.revision || !Array.isArray(e.durableOriginalIds) || !e.note?.trim() || !e.freshness || !e.availability || e.lastVerifiedAt !== null && !Number.isFinite(Date.parse(e.lastVerifiedAt))) fail("invalid visual evidence/freshness state");
+      for (const v of r.views || []) if (!v.evidence || !["legacy-observation", "live-only", "retained-capture", "accessible-session"].includes(v.evidence.kind) || v.evidence.sourceRevision > r.revision || !Number.isFinite(Date.parse(v.evidence.inspectedAt)) || v.evidence.kind === "retained-capture" && !v.capture || v.evidence.kind === "accessible-session" && (!v.evidence.sessionId || !v.evidence.uri) || v.evidence.kind === "live-only" && !/^https?:\/\//.test(v.evidence.uri || "")) fail("unresolvable visual evidence state");
+    }
+    if (r.motionTags !== void 0 && (!Array.isArray(r.motionTags) || r.motionTags.some((t) => typeof t !== "string" || !t.trim()) || new Set(r.motionTags).size !== r.motionTags.length)) fail("invalid motion tags");
+    if (r.temporalEvidence !== void 0 && (!Array.isArray(r.temporalEvidence) || r.temporalEvidence.some((v) => !v?.route || !v.observation?.trim() || !["agent", "human"].includes(v.assessor) || !Number.isInteger(v.viewport?.width) || !Number.isInteger(v.viewport?.height) || v.viewport.width < 1 || v.viewport.height < 1 || !/^[a-f0-9]{64}$/.test(v.sourceHash) || !/^[a-f0-9]{64}$/.test(v.scenarioHash) || !v.recording?.path || !/^[a-f0-9]{64}$/.test(v.recording.sha256)))) fail("invalid temporal evidence");
+    if (r.compositionTags !== void 0 && (!Array.isArray(r.compositionTags) || r.compositionTags.some((t) => typeof t !== "string" || !t.trim()) || new Set(r.compositionTags).size !== r.compositionTags.length)) fail("invalid composition tags");
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(r.id) || ids.has(r.id)) fail("invalid or duplicate id");
+    ids.add(r.id);
+    if (!Number.isInteger(r.revision) || r.revision < 1) fail("invalid revision");
+    if (!REFERENCE_FAMILIES.includes(r.primaryFamily)) fail("invalid primary family");
+    if (!["candidate", "live-screened", "deep-reviewed", "unavailable", "retired"].includes(r.evidenceLevel)) fail("invalid evidence level");
+    if (!["draft", "active", "retired"].includes(r.lifecycle) || !["live", "pending", "blocked", "retired"].includes(r.sourceStatus)) fail("invalid lifecycle/source status");
+    if (!["none", "one-image", "multiple-images", "product-ui"].includes(r.assetMinimum) || !["low", "medium", "high"].includes(r.complexity)) fail("invalid asset/complexity contract");
+    try {
+      const url = new URL(r.resolvedUrl || r.requestedUrl);
+      if (!/^https?:$/.test(url.protocol)) fail("invalid URL protocol");
+      const key = url.hostname.replace(/^www\./, "");
+      if (urls.has(key)) fail("duplicate publisher domain; review distinctness");
+      urls.add(key);
+    } catch {
+      fail("invalid URL");
+    }
+    for (const key of ["title", "adds", "lowComplexityAlternative"]) if (!r[key]?.trim()) fail(`missing ${key}`);
+    if (!r.creator || !r.discovery?.source || !r.discovery.url || !r.sourcing?.basis || !r.sourcing.researchRetention || !r.sourcing.redistribution || !r.coverage) fail("missing provenance/coverage");
+    if (!r.structure || ["opening", "navigation", "evidence", "density", "imageTypeRelationship", "interior", "responsive", "action"].some((key) => typeof r.structure[key] !== "string" || !String(r.structure[key]).trim()) || !Array.isArray(r.structure.sequence) || !r.structure.sequence.length) fail("incomplete structure");
+    for (const key of ["tags", "fitSignals", "visitorTasks", "observedRelationships", "lessons", "useWhen", "avoidWhen", "views", "limitations", "relatedExamples", "lessonIds"]) if (!Array.isArray(r[key])) fail(`missing ${key}`);
+    const screened = ["live-screened", "deep-reviewed"].includes(r.evidenceLevel);
+    if (screened && (!r.inspectedAt || !r.resolvedUrl || !r.views?.length || !r.observedRelationships?.length || !r.lessons?.length || r.sourceStatus !== "live")) fail("screened record lacks actual inspection");
+    if (!r.eligible || ["metadata", "images", "code"].some((key) => typeof r.eligible[key] !== "boolean")) fail("missing eligibility contract");
+    if (!r.sourcing || !["abstract-lessons-only", "cleared-material", "none"].includes(r.sourcing.generationUse)) fail("invalid sourcing contract");
+    if (r.eligible?.metadata && (!screened || r.lifecycle !== "active" || r.sourcing?.generationUse === "none")) fail("ineligible evidence admitted for generation");
+    if ((r.eligible?.images || r.eligible?.code) && r.sourcing?.generationUse !== "cleared-material") fail("uncleared external material admitted");
+    for (const v of Array.isArray(r.views) ? r.views : []) {
+      if (!v || !v.id || !v.route || !v.observation || !v.evidencePointer || !Number.isFinite(Date.parse(v.inspectedAt)) || !Number.isInteger(v.viewport?.width) || !Number.isInteger(v.viewport?.height) || v.viewport.width < 1 || v.viewport.height < 1 || !v.resolvedUrl || !["opening", "whole-page", "task"].includes(v.scope) || !Array.isArray(v.limitations)) fail(`incomplete view ${v?.id}`);
+      if (v?.capture && (!v.capture.path || !/^[a-f0-9]{64}$/.test(v.capture.sha256))) fail(`invalid capture hash ${v.id}`);
+    }
+    if (r.evidenceLevel === "deep-reviewed") {
+      for (const narrow of [false, true]) {
+        const views = (Array.isArray(r.views) ? r.views : []).filter((v) => v?.viewport && v.viewport.width < 600 === narrow);
+        if (!views.some((v) => v.scope === "opening") || !views.some((v) => v.scope === "whole-page")) fail(`missing ${narrow ? "mobile" : "desktop"} opening/full inspection`);
+        if (!views.some((v) => v.scope === "task" && v.state !== "opening")) fail(`missing ${narrow ? "mobile" : "desktop"} interior/task inspection`);
+      }
+      if (!r.structure?.interior || !r.structure?.responsive) fail("missing interior/mobile relationships");
+    }
+  }
+  return errors;
+}
+function loadReferenceCatalog(root, kernel, release = referencePolicy(root)?.release || REFERENCE_RELEASE) {
+  const base = join6(kernel || resolveKernelRoot(root) || root, `design-system/references/${referenceReleaseDirectory(release)}`);
+  const manifestPath = join6(base, "manifest.json");
+  if (!existsSync6(manifestPath)) throw new Error("Reference release unavailable; restore the pinned harness package");
+  const manifest = read2(manifestPath);
+  if (manifest.schemaVersion !== 1 || manifest.release !== release || manifest.labeledPreferenceData !== false) throw new Error("Unsupported reference manifest");
+  const body = readFileSync6(confinedReferencePath(base, manifest.catalog.path));
+  if (referenceHash(body) !== manifest.catalog.sha256) throw new Error("Reference catalog hash mismatch");
+  const catalog = JSON.parse(body.toString());
+  const errors = validateReferenceCatalog(catalog);
+  if (errors.length) throw new Error(`Reference catalog quarantined: ${errors.join("; ")}`);
+  validateReferenceDependencies(catalog, resolve5(base, "../../.."), base);
+  return { base, kernel: resolve5(base, "../../.."), manifest, catalog, manifestHash: referenceHash(readFileSync6(manifestPath)) };
+}
+function validateReferenceDependencies(catalog, releaseKernel, base) {
+  for (const record of catalog.records) for (const view of record.temporalEvidence || []) {
+    const path = confinedReferencePath(base, view.recording.path);
+    if (!existsSync6(path) || referenceHash(readFileSync6(path)) !== view.recording.sha256) throw new Error(`Missing or changed reference recording: ${record.id}`);
+  }
+  for (const record of catalog.records) for (const view of record.views) if (view.capture) {
+    const path = confinedReferencePath(base, view.capture.path);
+    if (!existsSync6(path) || referenceHash(readFileSync6(path)) !== view.capture.sha256) throw new Error(`Missing or changed reference capture: ${record.id}/${view.id}`);
+  }
+  const lessons = new Set(loadCompositionPack(releaseKernel).lessons.map((l) => l.id)), studies = loadReferenceStudies(releaseKernel, catalog.release);
+  const studyIds = new Set(studies.catalog.studies.map((s) => s.id)), referenceIds = new Set(catalog.records.map((r) => r.id));
+  for (const record of catalog.records) {
+    if (!record.lessonIds.length || record.lessonIds.some((id) => !lessons.has(id))) throw new Error(`Missing reference lesson link: ${record.id}`);
+    if (record.relatedExamples.some((id) => !studyIds.has(id))) throw new Error(`Missing original study link: ${record.id}`);
+    if (record.visualEvidence?.durableOriginalIds.some((id) => !studyIds.has(id))) throw new Error(`Missing durable original evidence: ${record.id}`);
+  }
+  for (const study of studies.catalog.studies) if (study.referenceIds.some((id) => !referenceIds.has(id))) throw new Error(`Missing study reference link: ${study.id}`);
+}
+function referenceSignals(root, release = referencePolicy(root)?.release || REFERENCE_RELEASE) {
+  const signals = compositionSignalsFromSite(root);
+  const text = (path) => existsSync6(join6(root, path)) ? read2(join6(root, path)) : {};
+  const business = text("onboarding/business.json"), request = text("agent/request.json"), story = text("onboarding/storyboard.json"), narrative = text("onboarding/narrative-brief.json"), media = text("onboarding/media-inventory.json");
+  const businessText = JSON.stringify([business.offer, business.audience, business.engagement]);
+  const extra = [];
+  if (/service|repair|advis|consult|law|account|contract|architect|practice/i.test(businessText)) extra.push("professional-service");
+  if (/shop|product|retail|collection/i.test(businessText)) extra.push("shop");
+  if (/\bsoftware\b|\bworkflow\b|\bapp\b|\bplatform\b/i.test(businessText)) extra.push("technical-product");
+  const usable = Array.isArray(media.assets) ? media.assets.filter((a) => a.inspected && a.disposition === "use" && a.kind !== "video") : [];
+  const hasUi = usable.some((a) => /\binterface\b|\bscreenshot\b|\bproduct ui\b|\bworkspace\b/i.test(`${a.role || ""} ${a.description || ""}`));
+  if (hasUi) extra.push("product-ui");
+  const established = signals.filter((s) => s.state === "known" && (!["approved-image", "multiple-images"].includes(s.id) || Array.isArray(media.assets))).map((s) => s.id);
+  const taskText = JSON.stringify([narrative.visitorQuestions, narrative.designOpportunities, story.pages, business.offer]);
+  const taskPatterns = { "evaluate-service": /service|scope|advis|repair|consult/i, "compare-options": /compare|choose|options|difference/i, "inspect-work": /project|portfolio|case study|finished work/i, "understand-process": /process|sequence|step|how it works/i, "shop-collection": /shop|purchase|retail|collection/i, "read-deeply": /essay|article|publication|read|guide/i, "find-location": /location|address|directions|parking/i, "book-inquiry": /book|inquir|contact|appointment|estimate/i, "explore-product": /software|product|workflow|demonstrat/i };
+  const visitorTasks = Object.entries(taskPatterns).filter(([, p]) => p.test(taskText)).map(([id]) => id).sort();
+  const roles = Array.isArray(story.pages) ? story.pages.map((p) => p.role || "") : [];
+  const result = { known: [.../* @__PURE__ */ new Set([...established, ...extra])].sort(), absent: [.../* @__PURE__ */ new Set([...signals.filter((s) => s.state === "absent").map((s) => s.id), ...Array.isArray(media.assets) && !hasUi ? ["product-ui"] : []])].sort(), theme: typeof request.theme === "string" ? request.theme : "", roles, visitorTasks, complexity: request.referenceComplexity === "high" ? "high" : request.referenceComplexity === "medium" ? "medium" : "low", origins: [...signals, { taskInference: "keyword fit from established business/narrative/storyboard; not a new customer fact", businessHash: referenceHash(JSON.stringify(business)), requestHash: referenceHash(JSON.stringify(request)), storyboardHash: referenceHash(JSON.stringify(story)), narrativeHash: referenceHash(JSON.stringify(narrative)), mediaHash: referenceHash(JSON.stringify(media)) }] };
+  if (release !== REFERENCE_RELEASE) {
+    result.contexts = businessContexts(businessText);
+    if (!/service|repair|advis|consult|law|account|contract|architect/i.test(businessText)) result.known = result.known.filter((id) => id !== "professional-service");
+    if (result.contexts.includes("creative-practice")) result.visitorTasks = [.../* @__PURE__ */ new Set([...(result.visitorTasks || []).filter((t) => t !== "evaluate-service"), "inspect-work", "read-deeply"])].sort();
+    result.visitorTasks = normalizeTasks(result.visitorTasks || [], release === CORRECTED_REFERENCE_RELEASE);
+    result.expression = expressionSignals(result.theme);
+  }
+  return result;
+}
+function selectReferences(pack, signals, acceptedIds, workingLimit = 4) {
+  if (pack.catalog.release !== REFERENCE_RELEASE) return selectCorrectedReferences(pack, signals, acceptedIds, workingLimit);
+  const excluded = [], eligible = [];
+  for (const r of pack.catalog.records) {
+    let exclusion = !r.eligible.metadata ? `evidence ${r.evidenceLevel}; metadata use not eligible` : r.lifecycle !== "active" ? "retired" : "";
+    if (["one-image", "multiple-images"].includes(r.assetMinimum) && !signals.known.includes("approved-image")) exclusion = "essential approved media absent or not established";
+    if (r.assetMinimum === "multiple-images" && !signals.known.includes("multiple-images")) exclusion = "multiple images absent or not established";
+    if (r.assetMinimum === "product-ui" && !signals.known.includes("product-ui")) exclusion = "actual product UI absent or not established";
+    if (r.coverage.immersive && signals.complexity !== "high") exclusion = "immersive interaction outside established complexity allowance";
+    if (exclusion) {
+      excluded.push({ id: r.id, reason: exclusion });
+      continue;
+    }
+    const hits = r.fitSignals.filter((s) => signals.known.includes(s));
+    const themeHits = [r.primaryFamily, ...r.tags].filter((t) => signals.theme.toLowerCase().includes(t.replaceAll("-", " ")));
+    const taskHits = r.visitorTasks.filter((task) => (signals.visitorTasks || []).includes(task));
+    if (!hits.length && !themeHits.length && !taskHits.length) {
+      excluded.push({ id: r.id, reason: "no established fit; expand discovery by recording task/evidence gaps" });
+      continue;
+    }
+    eligible.push({ id: r.id, revision: r.revision, score: hits.length * 3 + themeHits.length * 6 + Math.min(taskHits.length, 2) * 2 + (r.evidenceLevel === "deep-reviewed" ? 1 : 0), reasons: [...hits.map((h) => `fit:${h}`), ...themeHits.map((h) => `explicit-theme:${h}`), ...taskHits.map((t) => `visitor-task:${t}`)] });
+  }
+  eligible.sort((a, b) => b.score - a.score || referenceHash(`${JSON.stringify(signals)}:${a.id}`).localeCompare(referenceHash(`${JSON.stringify(signals)}:${b.id}`)));
+  const complementary = (pool, limit) => {
+    const result = [], remaining = [...pool];
+    while (remaining.length && result.length < limit) {
+      const best = remaining[0].score;
+      const near = remaining.filter((r) => r.score >= best - 2);
+      const gain = (id) => {
+        const r = pack.catalog.records.find((r2) => r2.id === id);
+        const seen = result.map((x) => pack.catalog.records.find((r2) => r2.id === x.id));
+        return Number(!seen.some((x) => x.primaryFamily === r.primaryFamily)) + (r.compositionTags || []).filter((tag) => !seen.some((x) => x.compositionTags?.includes(tag))).length;
+      };
+      near.sort((a, b) => gain(b.id) - gain(a.id) || b.score - a.score || pool.indexOf(a) - pool.indexOf(b));
+      const next = near[0];
+      result.push(next);
+      remaining.splice(remaining.indexOf(next), 1);
+    }
+    return result;
+  };
+  const shortlist = complementary(eligible, 10);
+  if (acceptedIds && new Set(acceptedIds).size !== acceptedIds.length) throw new Error("Duplicate accepted reference IDs");
+  const selected = acceptedIds ? acceptedIds.map((id) => {
+    const found = eligible.find((r) => r.id === id);
+    if (!found) throw new Error(`Accepted reference ${id} is unavailable/ineligible; explicitly revise reference analysis`);
+    return found;
+  }) : complementary(shortlist, workingLimit);
+  return { schemaVersion: 1, selectorVersion: REFERENCE_SELECTOR, release: pack.catalog.release, manifestHash: pack.manifestHash, catalogHash: pack.manifest.catalog.sha256, inputSignalHash: referenceHash(JSON.stringify(signals)), signals, eligible, excluded, shortlist, selected, accepted: !!acceptedIds, gaps: selected.length < 3 ? ["Fewer than three appropriate references; expand researched coverage or establish missing brief signals"] : [], inspectedEvidence: [], ties: [...new Set(eligible.map((r) => r.score))].map((score) => ({ score, ids: eligible.filter((r) => r.score === score).map((r) => r.id) })).filter((t) => t.ids.length > 1) };
+}
+function frozenReferenceSignals(root, accepted) {
+  const runs = join6(root, "agent/runs");
+  for (const name of existsSync6(runs) ? readdirSync(runs).filter((n) => n.endsWith(".design-context.json")) : []) {
+    const path = join6(runs, name);
+    if (statSync(path).size > 2e6) continue;
+    const wrapper = read2(path), m = wrapper.manifest;
+    const receipt = m?.referenceSelection, preparation = join6(root, "agent/preparations", name.slice(0, -".design-context.json".length) + ".json");
+    if (m?.nodeId !== "reference-analysis" || receipt?.inputSignalHash !== accepted.inputSignalHash || receipt.manifestHash !== accepted.manifestHash || !existsSync6(preparation)) continue;
+    const p = read2(preparation);
+    if (p.nodeId === "reference-analysis" && ["prepared", "consumed"].includes(p.status) && referenceHash(JSON.stringify(receipt.signals)) === accepted.inputSignalHash) return receipt.signals;
+  }
+  throw new Error("Accepted references need their frozen prepared analysis signals; explicitly revise analysis if unavailable");
+}
+function selectCorrectedReferences(pack, signals, acceptedIds, workingLimit = 3) {
+  const excluded = [], eligible = [];
+  for (const r of pack.catalog.records) {
+    const profile = r.selectionProfile;
+    if (!profile) throw new Error(`Corrected reference lacks normalized profile: ${r.id}`);
+    const essential = essentialAssetGap(profile.interpretation?.assetMinimum || r.assetMinimum, signals);
+    const reason = !r.eligible.metadata || r.lifecycle !== "active" || r.sourceStatus !== "live" || ["blocked", "unavailable", "retired", "redirect-unverified"].includes(r.visualEvidence?.availability || "") || ["retired", "unavailable", "candidate"].includes(r.evidenceLevel) ? "source unavailable/retired or metadata ineligible" : essential || (r.coverage.immersive && signals.complexity !== "high" ? "immersive dependency outside complexity allowance" : "");
+    if (reason) {
+      excluded.push({ id: r.id, reason });
+      continue;
+    }
+    const fit = fitScore(profile, r.fitSignals, signals, pack.catalog.release === CORRECTED_REFERENCE_RELEASE);
+    if (!fit.supported) {
+      excluded.push({ id: r.id, reason: "no specific task, expression or context fit" });
+      continue;
+    }
+    eligible.push({ id: r.id, revision: r.revision, ...fit, profile, reasons: [...fit.reasons, `evidence:${r.visualEvidence?.kind || "legacy-observation"}; fresh live inspection required before pixel claims`, ...profile.interpretation ? [`interpretation:${profile.interpretation.scope}; missing:${profile.interpretation.missingDependencies.join(",")}`] : []] });
+  }
+  const inputSignalHash = referenceHash(JSON.stringify(signals)), tie = (id) => referenceHash(inputSignalHash + ":" + id);
+  eligible.sort((a, b) => b.score - a.score || tie(a.id).localeCompare(tie(b.id)));
+  const shortlist = complementaryFit(eligible, 10, tie, pack.catalog.release === CORRECTED_REFERENCE_RELEASE);
+  if (acceptedIds && new Set(acceptedIds).size !== acceptedIds.length) throw new Error("Duplicate accepted reference IDs");
+  const selected = acceptedIds ? acceptedIds.map((id) => {
+    const match = eligible.find((r) => r.id === id);
+    if (!match) throw new Error(`Accepted reference ${id} is unavailable/ineligible; explicitly revise reference analysis`);
+    return match;
+  }) : complementaryFit(shortlist, workingLimit, tie, pack.catalog.release === CORRECTED_REFERENCE_RELEASE);
+  const expression = signals.expression || expressionSignals(signals.theme), gaps = [];
+  if (!selected.length) gaps.push("specific-fit-gap: broaden researched discovery or establish the visitor task and approved assets");
+  if (expression.uncertainty) gaps.push(`unsupported-expression: preserve exact request '${signals.theme}'; clarify interpretation or inspect suitable material`);
+  else if (expression.families.length && !selected.some((r) => r.profile.expressions.some((e) => expression.families.includes(e)))) gaps.push("expression-coverage-gap: no eligible selected lesson supports requested expression; inspect source or justify bounded interpretation");
+  return { schemaVersion: 1, selectorVersion: referenceSelectorVersion(pack.catalog.release), release: pack.catalog.release, manifestHash: pack.manifestHash, catalogHash: pack.manifest.catalog.sha256, inputSignalHash, signals, eligible, excluded, shortlist, selected, accepted: !!acceptedIds, gaps, inspectedEvidence: [], ties: [...new Set(eligible.map((r) => r.score))].map((score) => ({ score, ids: eligible.filter((r) => r.score === score).map((r) => r.id) })).filter((t) => t.ids.length > 1) };
+}
+function referenceContext(root, stage, kernel) {
+  const policy = referencePolicy(root);
+  if (!policy || !["reference-analysis", "direction", "storyboard", "representative", "representative-quality", "pages", "visual-review", "content-review", "refine"].includes(stage)) return void 0;
+  const pack = loadReferenceCatalog(root, kernel, policy.release);
+  if (policy.manifestHash && policy.manifestHash !== pack.manifestHash) throw new Error("Pinned reference manifest changed");
+  const path = join6(root, "onboarding/reference-analysis.json");
+  const analysis = existsSync6(path) ? read2(path) : void 0;
+  const accepted = stage !== "reference-analysis" ? analysis?.referenceSelection : void 0;
+  if (accepted && policy.release !== REFERENCE_RELEASE && accepted.selectorVersion !== referenceSelectorVersion(policy.release)) throw new Error("Accepted selector version changed; explicitly revise reference analysis");
+  if (accepted && accepted.manifestHash !== pack.manifestHash) throw new Error("Accepted reference release changed; explicitly revise reference analysis");
+  for (const chosen of accepted?.selected || []) if (!pack.catalog.records.some((r) => r.id === chosen.id && r.revision === chosen.revision)) throw new Error(`Accepted reference revision changed: ${chosen.id}`);
+  const receipt = selectReferences(pack, accepted && policy.release !== REFERENCE_RELEASE ? frozenReferenceSignals(root, accepted) : referenceSignals(root), accepted?.selected.map((r) => r.id), 3);
+  const summaries = receipt.selected.map((s) => {
+    const r = pack.catalog.records.find((r2) => r2.id === s.id);
+    return { id: s.id, revision: s.revision, reason: s.reasons.join(", "), summary: `${r.title}: ${r.adds}`, avoid: r.avoidWhen.join("; "), handle: `reference-${s.id}-r${s.revision}` };
+  });
+  const text = [`Reference release ${pack.catalog.release}; manifest ${pack.manifestHash}; signal ${receipt.inputSignalHash}. Advisory teaching only; preserve customer facts and exact theme.`, ...summaries.map((s) => `- ${s.id}@${s.revision}: ${s.summary.slice(0, 260)} Fit ${s.reason}. Avoid ${s.avoid.slice(0, 180)}. Expand ${s.handle}.`), ...receipt.gaps, "Inspect selected live routes or cleared captures before describing pixels. Delivery is not inspection. Record actual viewports/evidence and relationships in reference-analysis.referenceSelection; preserve the accepted idea in direction/storyboard and later review."].join("\n");
+  const expansions = summaries.map((s) => {
+    const r = pack.catalog.records.find((r2) => r2.id === s.id);
+    const text2 = JSON.stringify({ boundary: "Teaching only. No customer claims, code, branding or assets transfer from this record.", record: r }, null, 2);
+    return { id: s.handle, hash: referenceHash(text2), chars: text2.length, text: text2 };
+  });
+  const discoveryText = JSON.stringify(receipt, null, 2);
+  expansions.push({ id: "reference-discovery", hash: referenceHash(discoveryText), chars: discoveryText.length, text: discoveryText });
+  const teaching = referenceStudyExpansions(pack.kernel, receipt.signals, receipt.selected.map((r) => r.id), accepted?.teachingSelected, policy.release);
+  if (policy.teachingManifestHash && policy.teachingManifestHash !== teaching.pack.manifestHash) throw new Error("Pinned original teaching manifest changed");
+  if (accepted?.teachingManifestHash && accepted.teachingManifestHash !== teaching.pack.manifestHash) throw new Error("Accepted original teaching release changed; explicitly revise reference analysis");
+  expansions.push(...teaching.expansions);
+  const teachingText = teaching.selected.map((s) => `- Original study ${s.id}@${s.revision}: ${s.idea} Expand ${s.handle}; inspect its pinned desktop/mobile homepage and interior previews. Fictional facts never transfer.`).join("\n");
+  return { policy, pack, receipt: { ...receipt, gaps: [...receipt.gaps, ...teaching.gaps], teachingManifestHash: teaching.pack.manifestHash, teachingSelected: teaching.selected }, text: [text, teachingText, ...teaching.gaps].filter(Boolean).join("\n"), expansions };
+}
+function referenceCoverage(catalog) {
+  const screened = catalog.records.filter((r) => ["live-screened", "deep-reviewed"].includes(r.evidenceLevel)), deep = screened.filter((r) => r.evidenceLevel === "deep-reviewed");
+  const count = (records, key) => records.filter((r) => r.coverage[key]).length;
+  return { total: catalog.records.length, candidate: catalog.records.filter((r) => r.evidenceLevel === "candidate").length, screened: screened.length, deep: deep.length, eligibleMetadata: catalog.records.filter((r) => r.eligible.metadata).length, eligibleImages: catalog.records.filter((r) => r.eligible.images).length, unavailable: catalog.records.filter((r) => ["unavailable", "retired"].includes(r.evidenceLevel)).length, families: REFERENCE_FAMILIES.map((family) => ({ family, screened: screened.filter((r) => r.primaryFamily === family).length, deep: deep.filter((r) => r.primaryFamily === family).length, deepGap: Math.max(0, 3 - deep.filter((r) => r.primaryFamily === family).length) })), crossCutting: Object.fromEntries(["localProfessional", "sparseMedia", "informationDense", "immersive"].map((key) => [key, { screened: count(screened, key), deep: count(deep, key) }])), intersections: { localSparse: screened.filter((r) => r.coverage.localProfessional && r.coverage.sparseMedia).length, localDense: screened.filter((r) => r.coverage.localProfessional && r.coverage.informationDense).length, sparseDense: screened.filter((r) => r.coverage.sparseMedia && r.coverage.informationDense).length } };
+}
+
+export {
+  CALIBRATION_PACK_VERSION,
+  PROBE_TOKEN,
+  PROBE_RGB,
+  ACCURACY_PROBE_PHRASE,
+  solidPng,
+  resolveKernelRoot,
+  calibrationPackDir,
+  loadCalibrationManifest,
+  calibrationPackHash,
+  loadKnowledgeV2,
+  lessonExtension,
+  coverageReport,
+  loadCompositionPack,
+  compositionSignalsFromSite,
+  selectCompositionLessons,
+  compositionContextForStage,
+  loadReferenceStudies,
+  referenceStudyExpansions,
+  REFERENCE_RELEASE,
+  REFERENCE_SELECTOR,
+  INITIAL_CORRECTED_REFERENCE_RELEASE,
+  CORRECTED_REFERENCE_RELEASE,
+  CORRECTED_REFERENCE_SELECTOR,
+  referenceSelectorVersion,
+  referenceReleaseDirectory,
+  REFERENCE_FAMILIES,
+  referenceHash,
+  confinedReferencePath,
+  referencePolicy,
+  validateReferenceCatalog,
+  loadReferenceCatalog,
+  validateReferenceDependencies,
+  referenceSignals,
+  selectReferences,
+  frozenReferenceSignals,
+  referenceContext,
+  referenceCoverage
+};