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

package/bin/chunks/chunk-FOXUQXTV.js

@@ -0,0 +1,278 @@
+import {
+  findHarnessRoot
+} from "./chunk-HNORQ74T.js";
+
+// src/blocks/metadata.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+var hash = (parts) => createHash("sha256").update(parts.join("\n---vitris-block-source---\n")).digest("hex");
+function blockSourceHash(dir) {
+  return hash(["README.md", "template.html", "styles.css", "island.js"].map((name) => existsSync(join(dir, name)) ? readFileSync(join(dir, name), "utf8") : ""));
+}
+function blockPreviewRendererHash(root) {
+  return hash(["scripts/blocks-preview.ts", "src/compile/flatten.ts", "src/compile/site.ts", "src/compile/primitives.ts", "src/theme.ts", "src/types.ts"].map((name) => readFileSync(join(root, name), "utf8")));
+}
+function readBlockMeta(dir, id, slots) {
+  const file = join(dir, "block.meta.json");
+  if (!existsSync(file)) return void 0;
+  let m;
+  try {
+    m = JSON.parse(readFileSync(file, "utf8"));
+  } catch (e) {
+    throw new Error(`${id} metadata is not valid JSON: ${String(e)}`);
+  }
+  const errors = [];
+  const obj = (value) => value && typeof value === "object" && !Array.isArray(value);
+  const str = (value) => typeof value === "string" && value.trim().length > 0;
+  const strings = (value) => Array.isArray(value) && value.every(str);
+  if (m?.schemaVersion !== 1) errors.push("schemaVersion must be 1");
+  if (m?.id !== id) errors.push(`id must be ${id}`);
+  if (!Number.isInteger(m?.revision) || m.revision < 1) errors.push("revision must be a positive integer");
+  if (!["draft", "inspected", "pilot", "stable", "deprecated"].includes(m?.status)) errors.push("invalid status");
+  if (!str(m?.owner)) errors.push("owner is required");
+  if (m?.sourceHash !== blockSourceHash(dir)) errors.push("sourceHash is stale");
+  for (const [group, fields] of Object.entries({
+    fit: ["visitorJobs", "pageRoles", "useWhen", "avoidWhen"],
+    content: ["requiredSlots", "optionalSlots"],
+    composition: ["geometry"],
+    adaptation: ["flexible", "invariants", "customWhen"],
+    interaction: ["islands"],
+    evidence: ["provenance", "testedContexts", "accessibility"]
+  })) {
+    if (!obj(m?.[group])) {
+      errors.push(`${group} is required`);
+      continue;
+    }
+    for (const field of fields) if (!strings(m[group][field])) errors.push(`${group}.${field} must be a string array`);
+  }
+  if (!obj(m?.media) || !Number.isInteger(m.media.min) || !Number.isInteger(m.media.max) || m.media.min < 0 || m.media.max < m.media.min || !str(m.media.optionalBehavior) || !strings(m.media.aspect)) errors.push("invalid media contract");
+  if (!Array.isArray(m?.content?.testedItemCounts) || !m.content.testedItemCounts.every((n) => Number.isInteger(n) && n >= 0)) errors.push("invalid testedItemCounts");
+  for (const field of ["hierarchy", "alignment", "density", "mediaProminence", "boundary"]) if (!str(m?.composition?.[field])) errors.push(`composition.${field} is required`);
+  for (const field of ["readingOrder", "reflow", "crop"]) if (!str(m?.responsive?.[field])) errors.push(`responsive.${field} is required`);
+  if (!str(m?.interaction?.behavior)) errors.push("interaction.behavior is required");
+  if (m?.evidence?.previewManifest !== void 0) {
+    const manifest = m.evidence.previewManifest;
+    const target = str(manifest) ? resolve(dir, manifest) : "";
+    const rel = target ? relative(resolve(dir, "../../.."), target) : "";
+    const withinLibrary = target && !rel.startsWith("..") && !isAbsolute(rel);
+    if (!withinLibrary) errors.push("evidence.previewManifest must name a file in the kernel");
+    else if (!existsSync(target) && m.status !== "draft") errors.push("previewManifest is missing");
+  }
+  if (errors.length) throw new Error(`${id} metadata: ${errors.join("; ")}`);
+  const expectedRequired = slots.filter((s) => s.required).map((s) => s.name).sort();
+  const expectedOptional = slots.filter((s) => !s.required).map((s) => s.name).sort();
+  if (JSON.stringify([...m.content.requiredSlots].sort()) !== JSON.stringify(expectedRequired) || JSON.stringify([...m.content.optionalSlots].sort()) !== JSON.stringify(expectedOptional)) {
+    throw new Error(`${id} metadata slots disagree with template/README`);
+  }
+  return m;
+}
+function blockPreviewEvidence(dir, meta) {
+  if (!meta?.evidence.previewManifest) return { status: "unavailable" };
+  const file = join(dir, meta.evidence.previewManifest);
+  if (!existsSync(file)) return { status: "unavailable" };
+  try {
+    const manifest = JSON.parse(readFileSync(file, "utf8"));
+    const images = manifest.images;
+    const valid = manifest.blockId === meta.id && manifest.blockRevision === meta.revision && manifest.sourceHash === blockSourceHash(dir) && manifest.rendererHash === blockPreviewRendererHash(join(dir, "../../..")) && ["mobile", "desktop"].every((kind) => {
+      const image = images?.[kind];
+      const path = image?.file && join(dirname(file), image.file);
+      return path && existsSync(path) && createHash("sha256").update(readFileSync(path)).digest("hex") === image.hash;
+    });
+    return {
+      status: valid ? "current" : "stale",
+      mobile: images?.mobile?.file && join(dirname(file), images.mobile.file),
+      desktop: images?.desktop?.file && join(dirname(file), images.desktop.file),
+      hashes: { mobile: images?.mobile?.hash, desktop: images?.desktop?.hash }
+    };
+  } catch {
+    return { status: "stale" };
+  }
+}
+
+// src/agent/jev/block-catalog.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function sha(text) {
+  return createHash2("sha256").update(text).digest("hex");
+}
+function kernelBlocksRoot(kernel = findHarnessRoot()) {
+  return join2(kernel, "blocks");
+}
+function parseSlots(readme, template) {
+  const table = readme.match(/## Slots\s*\n([\s\S]*?)\n\n## /)?.[1] ?? "";
+  const documented = /* @__PURE__ */ new Map();
+  for (const row of table.matchAll(/^\|\s*`([^`]+)`\s*\|\s*(.+?)\s*\|\s*$/gm)) {
+    documented.set(row[1] === "(default)" ? "default" : row[1], row[2]);
+  }
+  const names = [...template.matchAll(/<slot(?:\s+name="([^"]+)")?[^>]*>/g)].map((m) => m[1] || "default");
+  const unique = [...new Set(names)];
+  return unique.map((name) => {
+    const desc = documented.get(name) || "";
+    const required = !/optional/i.test(desc);
+    return { name, required, description: desc };
+  });
+}
+function geometryFrom(html, css) {
+  const g = [];
+  if (/\bsplit\b/.test(html) || /\bsplit\b/.test(css)) g.push("split");
+  if (/\bgrid\b/.test(html)) g.push("grid");
+  if (/ratio-/.test(html) || /aspect-ratio/.test(css)) g.push("media-frame");
+  if (/section--roomy/.test(html)) g.push("roomy");
+  if (/sticky/.test(html) || /position:\s*sticky/.test(css)) g.push("sticky");
+  return g;
+}
+function loadBlockLibrary(kernel) {
+  const blocksRoot = kernel ? join2(kernel, "blocks") : kernelBlocksRoot();
+  const blocks = [];
+  if (!existsSync2(blocksRoot)) return { generatedFrom: "readme+index+template", blocks };
+  for (const cat of readdirSync(blocksRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort()) {
+    for (const name of readdirSync(join2(blocksRoot, cat), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort()) {
+      const dir = join2(blocksRoot, cat, name);
+      const readmePath = join2(dir, "README.md");
+      const templatePath = join2(dir, "template.html");
+      if (!existsSync2(readmePath) || !existsSync2(templatePath)) continue;
+      const readme = readFileSync2(readmePath, "utf8");
+      const template = readFileSync2(templatePath, "utf8");
+      const css = existsSync2(join2(dir, "styles.css")) ? readFileSync2(join2(dir, "styles.css"), "utf8") : "";
+      const look = readme.split("\n").map((l) => l.trim()).find((l) => l && !l.startsWith("#") && !l.startsWith("-") && !l.startsWith("```")) || "";
+      const media = (readme.match(/\*\*Media:\*\*\s*(.+)/) || [])[1] || "";
+      const registers = ((readme.match(/\*\*Registers:\*\*\s*(.+)/) || [])[1] || "").split(",").map((s) => s.trim()).filter(Boolean);
+      const variantLine = (readme.match(/\*\*Variants:\*\*\s*(.+)/) || [])[1] || "";
+      const variants = !variantLine || variantLine.startsWith("(none)") ? [] : variantLine.split(",").map((s) => s.trim()).filter(Boolean);
+      const example = (readme.match(/## Example\s*```html\s*([\s\S]*?)```/) || [])[1]?.trim() || "";
+      const slots = parseSlots(readme, template);
+      const meta = readBlockMeta(dir, `${cat}/${name}`, slots);
+      const previewPath = `dist/blocks/${cat}/${name}.html`;
+      blocks.push({
+        id: `${cat}/${name}`,
+        category: cat,
+        name,
+        look,
+        media,
+        mediaRequired: meta ? meta.media.min > 0 : /required|one |photo|portrait|cover|map/i.test(media) && !/optional|none/i.test(media),
+        registers,
+        variants,
+        slots,
+        interaction: meta ? meta.interaction.islands.length ? "island" : "static" : existsSync2(join2(dir, "island.js")) ? "island" : "static",
+        mobile: { hasMediaQuery: /@media/.test(css), notes: /@media/.test(css) ? "has-breakpoint" : "no-breakpoint" },
+        geometry: meta?.composition.geometry ?? geometryFrom(template, css),
+        example,
+        examplePath: `${cat}/${name}/README.md#example`,
+        previewPath,
+        previewHash: example ? sha(example + "\n" + readme + "\n" + template + "\n" + css) : sha(readme + "\n" + template + "\n" + css),
+        seesImages: false,
+        dir,
+        meta,
+        metadataSource: meta ? "block.meta.json" : "legacy-readme",
+        previewEvidence: blockPreviewEvidence(dir, meta)
+      });
+    }
+  }
+  return { generatedFrom: "readme+index+template", blocks };
+}
+function libraryContentHash(lib) {
+  return sha(lib.blocks.map((b) => JSON.stringify({
+    id: b.id,
+    look: b.look,
+    media: b.media,
+    slots: b.slots,
+    interaction: b.interaction,
+    geometry: b.geometry,
+    example: b.example,
+    registers: b.registers,
+    variants: b.variants,
+    mobile: b.mobile,
+    previewHash: b.previewHash,
+    meta: b.meta,
+    previewEvidence: { status: b.previewEvidence?.status, hashes: b.previewEvidence?.hashes }
+  })).join("\n"));
+}
+function hardFilterBlocks(lib, state) {
+  return lib.blocks.filter((b) => !b.meta || state.mediaCount >= b.meta.media.min);
+}
+function lexicalShortlist(lib, state, limit = 8) {
+  const role = (state.sectionRole || state.pageRole || state.sectionId || "").toLowerCase();
+  const aliases = {
+    header: ["navbar"],
+    navbar: ["navbar"],
+    proof: ["testimonial", "trust-strip", "about", "stats"],
+    testimonial: ["testimonial", "trust-strip"],
+    service: ["services"],
+    services: ["services"],
+    project: ["work", "gallery"],
+    work: ["work", "gallery"]
+  };
+  const matchingCategories = /* @__PURE__ */ new Set([role, ...aliases[role] || []]);
+  const terms = `${state.visitorJob} ${state.sectionPurpose || ""}`.toLowerCase().match(/[a-z]{4,}/g) || [];
+  const synonym = { licenses: "credential", licensed: "credential", qualifications: "credential", trust: "proof", compare: "comparison" };
+  const jobTerms = [...new Set(terms.flatMap((term) => [term, synonym[term]].filter((value) => !!value)))];
+  const scored = lib.blocks.map((b) => {
+    let score = 0;
+    if (matchingCategories.has(b.category) || b.id.includes(role) || b.name.includes(role)) score += 5;
+    const searchable = `${b.look} ${b.meta?.fit.visitorJobs.join(" ") || ""} ${b.meta?.fit.pageRoles.join(" ") || ""}`.toLowerCase();
+    score += Math.min(4, jobTerms.filter((term) => searchable.includes(term)).length * 2);
+    if (state.mediaCount === 0 && (b.meta?.media.min === 0 || /none|optional/i.test(b.media))) score += 2;
+    if (state.mediaCount > 0 && b.mediaRequired) score += 2;
+    if (state.interaction === "island" && b.interaction === "island") score += 2;
+    if (state.interaction === "accordion" && /faq|accordion/.test(b.id)) score += 3;
+    if (state.emphasis && b.look.toLowerCase().includes(state.emphasis.toLowerCase())) score += 1;
+    return { b, score };
+  }).filter((s) => s.score > 0).sort((a, c) => c.score - a.score || a.b.id.localeCompare(c.b.id));
+  const selected = [];
+  while (selected.length < Math.max(0, limit - 1) && scored.length) {
+    const bestScore = scored[0].score;
+    const tied = scored.filter((s) => s.score === bestScore);
+    const seen = new Set(selected.flatMap((b) => b.geometry));
+    tied.sort((a, b) => {
+      const novelty = (item) => item.b.geometry.filter((tag) => !seen.has(tag)).length;
+      return novelty(b) - novelty(a) || a.b.id.localeCompare(b.b.id);
+    });
+    const choice = tied[0];
+    selected.push(choice.b);
+    scored.splice(scored.indexOf(choice), 1);
+  }
+  return selected;
+}
+
+// src/blocks/library-profile.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+function readLibraryProfile(siteRoot) {
+  const file = join3(siteRoot, "launch.json");
+  if (!existsSync3(file)) return "legacy-v0";
+  const value = JSON.parse(readFileSync3(file, "utf8")).designLibraryProfile;
+  if (value === void 0 || value === null) return "legacy-v0";
+  if (value === "legacy-v0" || value === "slice-v1") return value;
+  throw new Error(`Unknown designLibraryProfile: ${String(value)}`);
+}
+function loadProfiledBlockLibrary(kernel, siteRoot) {
+  const profile = readLibraryProfile(siteRoot);
+  const library = loadBlockLibrary(kernel);
+  const legacyFile = join3(kernel, "design-system/library-releases/legacy-v0.json");
+  if (profile === "legacy-v0" && existsSync3(legacyFile)) {
+    const release = JSON.parse(readFileSync3(legacyFile, "utf8"));
+    const ids = new Set(release.blockIds);
+    library.blocks = library.blocks.filter((block) => ids.has(block.id)).map((block) => ({
+      ...block,
+      meta: void 0,
+      metadataSource: "legacy-readme",
+      previewEvidence: { status: "unavailable" }
+    }));
+  }
+  const releaseIdentity = createHash3("sha256").update(`${profile}
+${libraryContentHash(library)}`).digest("hex");
+  return { profile, releaseIdentity, library };
+}
+
+export {
+  blockSourceHash,
+  blockPreviewRendererHash,
+  loadBlockLibrary,
+  libraryContentHash,
+  hardFilterBlocks,
+  lexicalShortlist,
+  loadProfiledBlockLibrary
+};