@tryvitris/website-harness 0.1.0-beta.6 → 0.1.0-beta.7

package/bin/chunks/{chunk-E5Y46VBX.js → chunk-VTI32UGJ.js}

@@ -2,14 +2,12 @@ import {
   buildSite,
   connectForms,
   loadSiteDir
-} from "./chunk-4GZCAWWK.js";
-import {
-  findHarnessRoot
-} from "./chunk-HNORQ74T.js";
+} from "./chunk-4MFPATAB.js";
 import {
   leadsJs
-} from "./chunk-YCVGD2CG.js";
+} from "./chunk-ZIROO2U4.js";
 import {
+  acquirePathLock,
   files,
   fingerprint,
   json,
@@ -147,15 +145,51 @@ function pageFile(path) {
   return decoded === "/" ? "index.html" : `${decoded.replace(/^\/|\/$/g, "")}/index.html`;
 }
 
+// src/cli/root.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join as join2, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function findHarnessRoot(startDir) {
+  if ((process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL) && existsSync2(process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL)) {
+    return resolve(process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL);
+  }
+  let curr = resolve(startDir || dirname(fileURLToPath(import.meta.url)));
+  for (let i = 0; i < 6; i++) {
+    const candidateTmpl = join2(curr, "templates/site");
+    const candidatePkg = join2(curr, "package.json");
+    if (existsSync2(candidateTmpl) && existsSync2(candidatePkg)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(candidatePkg, "utf8"));
+        if (["@tryvitris/website-harness", "@tryvitris/harness", "@vitris/harness", "@vitris/kernel"].includes(pkg.name)) {
+          return curr;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(curr);
+    if (parent === curr) break;
+    curr = parent;
+  }
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  for (const rel of [".", "..", "../.."]) {
+    const target = resolve(moduleDir, rel);
+    if (existsSync2(join2(target, "templates/site"))) {
+      return target;
+    }
+  }
+  throw new Error("Could not locate @tryvitris/website-harness root directory containing templates/site");
+}
+var findKernelRoot = findHarnessRoot;
+
 // src/build/verified.ts
-import { cpSync as cpSync2, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname4, join as join6, resolve as resolve2, sep as sep2 } from "node:path";
-import { writeFileSync as writeFileSync4 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname5, join as join8, resolve as resolve3, sep as sep2 } from "node:path";
+import { writeFileSync as writeFileSync5 } from "node:fs";
 
 // src/preserve/build.ts
-import { cpSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
-import { dirname, join as join3, resolve, sep } from "node:path";
-import { randomUUID } from "node:crypto";
+import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join5, resolve as resolve2, sep } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/preserve/runtime.ts
 var preserveRuntime = `(() => {
@@ -304,18 +338,18 @@ var preserveRuntime = `(() => {
 })();`;
 
 // src/preserve/supplement.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 function preserveManifest(root) {
-  const manifest = JSON.parse(readFileSync2(join2(root, "onboarding/preserve.json"), "utf8"));
-  const index = join2(root, "onboarding/preserve-supplements.json");
-  if (existsSync2(index)) for (const file of JSON.parse(readFileSync2(index, "utf8")).files) {
-    const supplement = JSON.parse(readFileSync2(within(root, file), "utf8"));
+  const manifest = JSON.parse(readFileSync3(join3(root, "onboarding/preserve.json"), "utf8"));
+  const index = join3(root, "onboarding/preserve-supplements.json");
+  if (existsSync3(index)) for (const file of JSON.parse(readFileSync3(index, "utf8")).files) {
+    const supplement = JSON.parse(readFileSync3(within(root, file), "utf8"));
     if (supplement.sourceUrl !== manifest.sourceUrl || supplement.capturedAt !== manifest.capturedAt) throw Error("Asset supplement does not match the original capture");
     manifest.warnings = [.../* @__PURE__ */ new Set([...manifest.warnings, ...supplement.warnings || []])];
     if (supplement.blockers?.length) manifest.blockers = [.../* @__PURE__ */ new Set([...manifest.blockers || [], ...supplement.blockers])];
     for (const page of supplement.pages || []) {
-      within(join2(root, "preserved"), page.file);
+      within(join3(root, "preserved"), page.file);
       page.references.forEach((r) => within(root, r.file));
       if (page.sourceFailure) within(root, page.sourceFailure.responseFile);
       if (new URL(page.url).origin !== new URL(manifest.sourceUrl).origin || new URL(page.url).pathname !== page.path || manifest.pages.some((p) => p.path === page.path || p.file.toLowerCase() === page.file.toLowerCase())) throw Error("Page supplement would replace a captured route or leave its source");
@@ -323,7 +357,7 @@ function preserveManifest(root) {
     }
     for (const asset of supplement.assets || []) {
       within(root, asset.referenceFile);
-      within(join2(root, "preserved"), asset.file);
+      within(join3(root, "preserved"), asset.file);
       if (manifest.assets.some((a) => a.file === asset.file || a.url === asset.url)) throw Error("Asset supplement would replace a captured asset");
       manifest.assets.push(asset);
       if (asset.captureError) manifest.blockers = [.../* @__PURE__ */ new Set([...manifest.blockers || [], asset.captureError + "; missing authored asset retained as an empty placeholder, not claimed as preserved bytes"])];
@@ -332,17 +366,64 @@ function preserveManifest(root) {
   return manifest;
 }
 
+// src/build/archives.ts
+import { randomUUID } from "node:crypto";
+import { lstatSync, mkdirSync, readdirSync, readFileSync as readFileSync4, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join as join4 } from "node:path";
+function archivePreviousBuild(root, previous) {
+  const archiveRoot = within(root, ".vitris/build-archives");
+  mkdirSync(archiveRoot, { recursive: true });
+  const unlock = acquirePathLock(join4(archiveRoot, "retention"));
+  try {
+    const id = randomUUID(), now = Date.now();
+    const priorTimes = readdirSync(archiveRoot).flatMap((name) => {
+      if (!/^[0-9a-f-]{36}$/.test(name)) return [];
+      try {
+        const manifest = JSON.parse(readFileSync4(within(root, `.vitris/build-archives/${name}/archive.json`), "utf8"));
+        return manifest.version === 1 && manifest.id === name && Number.isSafeInteger(manifest.createdAt) && manifest.createdAt <= now + 6e4 ? [manifest.createdAt] : [];
+      } catch {
+        return [];
+      }
+    });
+    const createdAt = Math.max(now, ...priorTimes.map((time) => time + 1));
+    const folder = within(root, `.vitris/build-archives/${id}`);
+    const hash2 = fingerprint(previous, ["."]);
+    mkdirSync(folder);
+    renameSync(previous, join4(folder, "dist"));
+    writeFileSync(join4(folder, "archive.json"), JSON.stringify({ version: 1, id, createdAt, hash: hash2 }) + "\n", { flag: "wx" });
+    const candidates = readdirSync(archiveRoot).flatMap((name) => {
+      if (!/^[0-9a-f-]{36}$/.test(name)) return [];
+      const candidate = within(root, `.vitris/build-archives/${name}`);
+      try {
+        if (!lstatSync(candidate).isDirectory() || lstatSync(candidate).isSymbolicLink()) return [];
+        const entries = readdirSync(candidate).sort();
+        if (entries.join(",") !== "archive.json,dist") return [];
+        const manifestPath = within(root, `.vitris/build-archives/${name}/archive.json`);
+        const dist = within(root, `.vitris/build-archives/${name}/dist`);
+        const manifest = JSON.parse(readFileSync4(manifestPath, "utf8"));
+        if (manifest.version !== 1 || manifest.id !== name || !Number.isSafeInteger(manifest.createdAt) || manifest.hash !== fingerprint(dist, ["."])) return [];
+        return [{ candidate, createdAt: manifest.createdAt, name }];
+      } catch {
+        return [];
+      }
+    }).sort((a, b) => b.createdAt - a.createdAt || b.name.localeCompare(a.name));
+    for (const stale of candidates.slice(3)) rmSync(stale.candidate, { recursive: true });
+  } finally {
+    unlock();
+  }
+}
+
 // src/preserve/build.ts
-async function buildPreservedSite(siteRoot, output = join3(siteRoot, "dist")) {
-  const root = resolve(siteRoot), out = resolve(output), source = join3(root, "preserved");
-  if (out === root || root.startsWith(out + sep) || ["preserved", "agent", "onboarding", "public", "pages", "components", "media", "theme", "artifacts"].some((p) => out === join3(root, p) || out.startsWith(join3(root, p) + sep))) throw new Error("Preserve build output cannot overwrite site source");
+async function buildPreservedSite(siteRoot, output = join5(siteRoot, "dist")) {
+  const root = resolve2(siteRoot), out = resolve2(output), source = join5(root, "preserved");
+  if (out === root || root.startsWith(out + sep) || ["preserved", "agent", "onboarding", "public", "pages", "components", "media", "theme", "artifacts"].some((p) => out === join5(root, p) || out.startsWith(join5(root, p) + sep))) throw new Error("Preserve build output cannot overwrite site source");
   const config = preserveConfig(root);
   const manifest = preserveManifest(root);
   if (config.mode !== "preserve" || !["vitris-v1", "vitris-v2"].includes(manifest.adapter) || !manifest.pages.length) throw new Error("Missing preserve capture; run vitris run first");
   if (new URL(config.sourceUrl).href !== manifest.sourceUrl) throw new Error("Source URL differs from the captured site; create a new preservation directory");
   files(source);
-  const stage = `${out}.stage-${randomUUID()}`;
-  mkdirSync(dirname(stage), { recursive: true });
+  const stage = `${out}.stage-${randomUUID2()}`;
+  mkdirSync2(dirname2(stage), { recursive: true });
   cpSync(source, stage, { recursive: true });
   let backend = "";
   if (config.backendOrigin) {
@@ -351,43 +432,50 @@ async function buildPreservedSite(siteRoot, output = join3(siteRoot, "dist")) {
     backend = url.origin;
   }
   for (const file of files(stage).filter((f) => f.endsWith(".html"))) {
-    let html = readFileSync3(file, "utf8");
+    let html = readFileSync5(file, "utf8");
     if (backend && config.forms?.length) {
-      const path = manifest.pages.find((p) => join3(stage, p.file) === file)?.path || "/";
+      const path = manifest.pages.find((p) => join5(stage, p.file) === file)?.path || "/";
       html = connectForms(html, backend, path, config.forms);
       html = html.replace(/<\/head>/i, "<style>.c-lead-status:empty{display:none}</style></head>");
       html = html.replace(/<\/body>/i, '<script src="/_preserve/leads.js" defer></script></body>');
     }
-    writeFileSync(file, html);
+    writeFileSync2(file, html);
   }
-  if (backend && config.forms?.length) writeFileSync(join3(stage, "_preserve/leads.js"), leadsJs);
-  writeFileSync(join3(stage, "_preserve/runtime.js"), preserveRuntime);
-  writeFileSync(join3(stage, "robots.txt"), "User-agent: *\nDisallow: /\n");
+  if (backend && config.forms?.length) writeFileSync2(join5(stage, "_preserve/leads.js"), leadsJs);
+  writeFileSync2(join5(stage, "_preserve/runtime.js"), preserveRuntime);
+  writeFileSync2(join5(stage, "robots.txt"), "User-agent: *\nDisallow: /\n");
   const rewrites = manifest.pages.filter((p) => p.file.startsWith("_preserve/routes/")).map((p) => `${p.path} /${p.file} 200`);
-  if (rewrites.length) writeFileSync(join3(stage, "_redirects"), rewrites.join("\n") + "\n");
+  if (rewrites.length) writeFileSync2(join5(stage, "_redirects"), rewrites.join("\n") + "\n");
   const connected = backend && config.forms?.length;
-  const frameOrigins = [...new Set(files(stage).filter((f) => f.endsWith(".html")).flatMap((f) => iframeSources(readFileSync3(f, "utf8")).filter((src) => readOnlyEmbedProvider(src)).map((src) => new URL(approvedEmbedUrl(src)).origin)))];
+  const frameOrigins = [...new Set(files(stage).filter((f) => f.endsWith(".html")).flatMap((f) => iframeSources(readFileSync5(f, "utf8")).filter((src) => readOnlyEmbedProvider(src)).map((src) => new URL(approvedEmbedUrl(src)).origin)))];
   if (connected) frameOrigins.push("https://challenges.cloudflare.com");
-  writeFileSync(join3(stage, "_headers"), `/*
+  writeFileSync2(join5(stage, "_headers"), `/*
   X-Robots-Tag: noindex, nofollow
   Content-Security-Policy: default-src 'self'; img-src 'self' data: blob:; font-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self'${connected ? " https://challenges.cloudflare.com" : ""}; connect-src 'self'${connected ? " " + backend + " https://challenges.cloudflare.com" : ""}; frame-src ${frameOrigins.length ? frameOrigins.join(" ") : "'none'"}; object-src 'none'; base-uri 'self'; form-action 'self'${connected ? " " + backend : ""}
 `);
-  writeFileSync(join3(stage, "404.html"), '<!doctype html><html><head><meta name="robots" content="noindex"></head><body><h1>Page not found</h1></body></html>');
-  save(join3(stage, "build-evidence.json"), { version: 1, mode: "preserve", compilerHash: fingerprint(findHarnessRoot(), ["src/preserve", "src/forms", "src/runtime/leads.ts", "src/compile/flatten.ts"]) });
-  const previous = `${out}.previous-${randomUUID()}`;
-  if (existsSync3(out)) replacePath(out, previous);
+  writeFileSync2(join5(stage, "404.html"), '<!doctype html><html><head><meta name="robots" content="noindex"></head><body><h1>Page not found</h1></body></html>');
+  save(join5(stage, "build-evidence.json"), { version: 1, mode: "preserve", compilerHash: fingerprint(findHarnessRoot(), ["src/preserve", "src/forms", "src/runtime/leads.ts", "src/compile/flatten.ts"]) });
+  const previous = `${out}.previous-${randomUUID2()}`;
+  if (existsSync5(out)) replacePath(out, previous);
   try {
     replacePath(stage, out);
   } catch (error) {
-    if (existsSync3(previous)) replacePath(previous, out);
+    if (existsSync5(previous)) replacePath(previous, out);
     throw error;
   }
+  if (out === join5(root, "dist") && existsSync5(previous)) {
+    try {
+      archivePreviousBuild(root, previous);
+    } catch (error) {
+      console.warn(`Could not finish archiving previous build; inspect the previous-build and archive folders: ${String(error)}`);
+    }
+  }
 }
 
 // src/build/responsive-media.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join4, relative } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join6, relative } from "node:path";
 import { parse as parse2 } from "parse5";
 import sharp from "sharp";
 var hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
@@ -404,7 +492,7 @@ async function responsiveMedia(dist, cacheDir) {
   const report = { version: 1, images: [], warnings: [] };
   const generated = /* @__PURE__ */ new Map();
   for (const file of files(dist).filter((p) => p.endsWith(".html"))) {
-    let html = readFileSync4(file, "utf8");
+    let html = readFileSync6(file, "utf8");
     const edits = [];
     const images = elements(parse2(html, { sourceCodeLocationInfo: true })).filter((el) => el.tagName === "img");
     if (images.filter((el) => attr(el, "data-media-priority") === "critical").length > 1) report.warnings.push(`${relative(dist, file)}: more than one critical image; check mobile/desktop visibility`);
@@ -426,10 +514,10 @@ async function responsiveMedia(dist, cacheDir) {
       const picture = el.parentNode && "tagName" in el.parentNode && el.parentNode.tagName === "picture";
       if (src && !/^(?:[a-z]+:|\/\/|#)/i.test(src) && /\.(?:jpe?g|png|webp|avif)$/i.test(src) && !attr(el, "srcset") && !picture && attr(el, "data-media-optimize") !== "off") {
         const decoded = decodeURIComponent(src);
-        const source = within(dist, decoded.startsWith("/") ? decoded.slice(1) : join4(relative(dist, dirname2(file)), decoded));
-        if (!existsSync4(source)) throw new Error(`Missing asset (image): ${src} in ${relative(dist, file)}`);
+        const source = within(dist, decoded.startsWith("/") ? decoded.slice(1) : join6(relative(dist, dirname3(file)), decoded));
+        if (!existsSync6(source)) throw new Error(`Missing asset (image): ${src} in ${relative(dist, file)}`);
         const format = attr(el, "data-media-format") === "avif" ? "avif" : "webp";
-        const bytes = readFileSync4(source), digest2 = hash(bytes), key = digest2 + "-" + format;
+        const bytes = readFileSync6(source), digest2 = hash(bytes), key = digest2 + "-" + format;
         if (!generated.has(key)) {
           const meta = await sharp(bytes, { limitInputPixels: 8e7 }).metadata();
           if ((meta.pages || 1) > 1 || !meta.width || !meta.height) generated.set(key, null);
@@ -439,19 +527,19 @@ async function responsiveMedia(dist, cacheDir) {
             const variants2 = [];
             const widths = [...new Set([480, 768, 1280, 1920].filter((w) => w < width).concat(Math.min(width, 1920)))];
             for (const w of widths) {
-              const cache = join4(cacheDir, `v1-sharp-${sharp.versions.sharp}-${key}-${w}`);
+              const cache = join6(cacheDir, `v1-sharp-${sharp.versions.sharp}-${key}-${w}`);
               let output;
-              if (existsSync4(cache)) output = readFileSync4(cache);
+              if (existsSync6(cache)) output = readFileSync6(cache);
               else {
                 const pipeline = sharp(bytes).rotate().resize({ width: w, withoutEnlargement: true });
                 output = await (format === "avif" ? pipeline.avif({ quality: 52, effort: 4 }) : pipeline.webp({ quality: 78, effort: 4 })).toBuffer();
-                mkdirSync2(cacheDir, { recursive: true });
-                writeFileSync2(cache, output);
+                mkdirSync3(cacheDir, { recursive: true });
+                writeFileSync3(cache, output);
               }
               const sha256 = hash(output), url = `/media/optimized/${sha256}.${format}`;
               const dimensions = await sharp(output).metadata();
-              mkdirSync2(join4(dist, "media/optimized"), { recursive: true });
-              writeFileSync2(join4(dist, url.slice(1)), output);
+              mkdirSync3(join6(dist, "media/optimized"), { recursive: true });
+              writeFileSync3(join6(dist, url.slice(1)), output);
               variants2.push({ url, width: dimensions.width, height: dimensions.height, bytes: output.length, sha256 });
             }
             generated.set(key, variants2);
@@ -480,58 +568,58 @@ async function responsiveMedia(dist, cacheDir) {
       edits.push({ start: loc.startOffset, end: loc.endOffset, value: "<img" + el.attrs.map((a) => ` ${a.name}="${escapeHtml(a.value)}"`).join("") + ">" });
     }
     for (const edit of edits.sort((a, b) => b.start - a.start)) html = html.slice(0, edit.start) + edit.value + html.slice(edit.end);
-    writeFileSync2(file, html);
+    writeFileSync3(file, html);
   }
-  writeFileSync2(join4(dist, "media-manifest.json"), JSON.stringify(report, null, 2) + "\n");
+  writeFileSync3(join6(dist, "media-manifest.json"), JSON.stringify(report, null, 2) + "\n");
   return report;
 }
 
 // src/build/static-output.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync } from "node:fs";
-import { dirname as dirname3, join as join5, relative as relative2 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, unlinkSync } from "node:fs";
+import { dirname as dirname4, join as join7, relative as relative2 } from "node:path";
 import { parse as parse3 } from "parse5";
 var digest = (bytes) => createHash2("sha256").update(bytes).digest("hex");
 function finalizeStaticOutput(dist, publicOrigin) {
-  mkdirSync3(join5(dist, "assets/immutable"), { recursive: true });
-  if (!existsSync5(join5(dist, "404.html"))) writeFileSync3(join5(dist, "404.html"), existsSync5(join5(dist, "404/index.html")) ? readFileSync5(join5(dist, "404/index.html")) : '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><meta name="robots" content="noindex"><title>Page not found</title></head><body><main><h1>Page not found</h1><p>This address is unavailable.</p><a href="/">Return home</a></main></body></html>');
+  mkdirSync4(join7(dist, "assets/immutable"), { recursive: true });
+  if (!existsSync7(join7(dist, "404.html"))) writeFileSync4(join7(dist, "404.html"), existsSync7(join7(dist, "404/index.html")) ? readFileSync7(join7(dist, "404/index.html")) : '<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><meta name="robots" content="noindex"><title>Page not found</title></head><body><main><h1>Page not found</h1><p>This address is unavailable.</p><a href="/">Return home</a></main></body></html>');
   const mapped = /* @__PURE__ */ new Map();
   const immutable = /* @__PURE__ */ new Set();
   for (const file of files(dist).filter((f) => f.endsWith(".css"))) {
-    let css = readFileSync5(file, "utf8");
+    let css = readFileSync7(file, "utf8");
     css = css.replace(/url\(\s*(["']?)data:(?:font\/woff2?|application\/(?:font-woff|x-font-woff));base64,([a-z0-9+/=\s]+)\1\s*\)/gi, (match, _quote, encoded) => {
       const bytes = Buffer.from(encoded.replace(/\s/g, ""), "base64");
       const signature = bytes.subarray(0, 4).toString();
       if (!["wOF2", "wOFF"].includes(signature)) return match;
       const url = `/assets/immutable/${digest(bytes)}.${signature === "wOF2" ? "woff2" : "woff"}`;
-      mkdirSync3(join5(dist, "assets/immutable"), { recursive: true });
-      writeFileSync3(join5(dist, url.slice(1)), bytes);
+      mkdirSync4(join7(dist, "assets/immutable"), { recursive: true });
+      writeFileSync4(join7(dist, url.slice(1)), bytes);
       immutable.add(url);
       return `url("${url}")`;
     });
-    if (dirname3(file) === join5(dist, "assets/immutable")) css = css.replace(/url\(\s*(["']?)(?![a-z]+:|\/|#)([^)'"\s]+)\1\s*\)/gi, (_m, _q, url) => `url("/${url}")`);
+    if (dirname4(file) === join7(dist, "assets/immutable")) css = css.replace(/url\(\s*(["']?)(?![a-z]+:|\/|#)([^)'"\s]+)\1\s*\)/gi, (_m, _q, url) => `url("/${url}")`);
     css = css.replace(/url\(\s*(["']?)([^)'"\s]+\.woff2?)\1\s*\)/gi, (match, _q, url) => {
       if (/^(?:[a-z]+:|\/\/)/i.test(url)) return match;
-      const path = within(dist, url.startsWith("/") ? url.slice(1) : join5(relative2(dist, dirname3(file)), url));
-      if (!existsSync5(path)) return match;
-      const bytes = readFileSync5(path), next2 = `/assets/immutable/${digest(bytes)}.${url.split(".").at(-1)}`;
-      writeFileSync3(join5(dist, next2.slice(1)), bytes);
+      const path = within(dist, url.startsWith("/") ? url.slice(1) : join7(relative2(dist, dirname4(file)), url));
+      if (!existsSync7(path)) return match;
+      const bytes = readFileSync7(path), next2 = `/assets/immutable/${digest(bytes)}.${url.split(".").at(-1)}`;
+      writeFileSync4(join7(dist, next2.slice(1)), bytes);
       immutable.add(next2);
       return `url("${next2}")`;
     });
     css = css.replace(/@font-face\s*\{[^}]*\}/gi, (rule) => /font-display\s*:/.test(rule) ? rule : rule.slice(0, -1) + ";font-display:swap}");
-    writeFileSync3(file, css);
+    writeFileSync4(file, css);
     const rel = "/" + relative2(dist, file).replaceAll("\\", "/");
     const next = `/assets/immutable/${digest(css)}.css`;
-    writeFileSync3(join5(dist, next.slice(1)), css);
+    writeFileSync4(join7(dist, next.slice(1)), css);
     mapped.set(rel, next);
     immutable.add(next);
     if (rel !== next && /^\/assets\/immutable\/[a-f0-9]{64}\.css$/.test(rel)) unlinkSync(file);
   }
   for (const name of ["islands.js", "beacon.js"]) {
-    if (!existsSync5(join5(dist, name))) continue;
-    const bytes = readFileSync5(join5(dist, name)), url = `/assets/immutable/${digest(bytes)}.js`;
-    writeFileSync3(join5(dist, url.slice(1)), bytes);
+    if (!existsSync7(join7(dist, name))) continue;
+    const bytes = readFileSync7(join7(dist, name)), url = `/assets/immutable/${digest(bytes)}.js`;
+    writeFileSync4(join7(dist, url.slice(1)), bytes);
     mapped.set("/" + name, url);
     immutable.add(url);
   }
@@ -541,7 +629,7 @@ function finalizeStaticOutput(dist, publicOrigin) {
   }
   const routes = new Set(files(dist).filter((f) => f.endsWith("index.html")).map((f) => "/" + relative2(dist, f).replaceAll("\\", "/").replace(/index\.html$/, "")));
   for (const file of files(dist).filter((f) => f.endsWith(".html"))) {
-    let html = readFileSync5(file, "utf8");
+    let html = readFileSync7(file, "utf8");
     for (const [old, next] of mapped) html = html.replaceAll(`"${old}"`, `"${next}"`).replaceAll(`'${old}'`, `'${next}'`);
     const edits = [];
     let hasIcon = false;
@@ -568,57 +656,57 @@ function finalizeStaticOutput(dist, publicOrigin) {
     walk(parse3(html, { sourceCodeLocationInfo: true }));
     for (const edit of edits.sort((a, b) => b.start - a.start)) html = html.slice(0, edit.start) + edit.value + html.slice(edit.end);
     if (!hasIcon) {
-      const icon = existsSync5(join5(dist, "favicon.ico")) ? "/favicon.ico" : "/favicon.svg";
-      if (!existsSync5(join5(dist, icon.slice(1)))) writeFileSync3(join5(dist, "favicon.svg"), '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#20252c"/><g fill="none" stroke="#fff" stroke-width="3"><circle cx="32" cy="32" r="20"/><ellipse cx="32" cy="32" rx="9" ry="20"/><path d="M12 32h40M16 21h32M16 43h32"/></g></svg>');
+      const icon = existsSync7(join7(dist, "favicon.ico")) ? "/favicon.ico" : "/favicon.svg";
+      if (!existsSync7(join7(dist, icon.slice(1)))) writeFileSync4(join7(dist, "favicon.svg"), '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#20252c"/><g fill="none" stroke="#fff" stroke-width="3"><circle cx="32" cy="32" r="20"/><ellipse cx="32" cy="32" rx="9" ry="20"/><path d="M12 32h40M16 21h32M16 43h32"/></g></svg>');
       html = html.replace(/<\/head\s*>/i, `<link rel="icon" href="${icon}" type="${icon.endsWith(".ico") ? "image/x-icon" : "image/svg+xml"}"></head>`);
     }
-    writeFileSync3(file, html);
+    writeFileSync4(file, html);
   }
-  const sitemap = join5(dist, "sitemap.xml");
-  if (existsSync5(sitemap)) writeFileSync3(sitemap, readFileSync5(sitemap, "utf8").replace(/<loc>([^<]+)<\/loc>/g, (_m, loc) => {
+  const sitemap = join7(dist, "sitemap.xml");
+  if (existsSync7(sitemap)) writeFileSync4(sitemap, readFileSync7(sitemap, "utf8").replace(/<loc>([^<]+)<\/loc>/g, (_m, loc) => {
     const path = publicOrigin && loc.startsWith(publicOrigin.replace(/\/$/, "")) ? loc.slice(publicOrigin.replace(/\/$/, "").length) : loc;
     return `<loc>${loc}${path !== "/" && routes.has(path.replace(/\/$/, "") + "/") && !loc.endsWith("/") ? "/" : ""}</loc>`;
   }));
-  const headersPath = join5(dist, "_headers");
-  const headers = existsSync5(headersPath) ? readFileSync5(headersPath, "utf8") : "";
-  writeFileSync3(headersPath, headers + "\n# Vitris content-addressed build assets\n/assets/immutable/*\n  Cache-Control: public, max-age=31536000, immutable\n/media/optimized/*\n  Cache-Control: public, max-age=31536000, immutable\n");
+  const headersPath = join7(dist, "_headers");
+  const headers = existsSync7(headersPath) ? readFileSync7(headersPath, "utf8") : "";
+  writeFileSync4(headersPath, headers + "\n# Vitris content-addressed build assets\n/assets/immutable/*\n  Cache-Control: public, max-age=31536000, immutable\n/media/optimized/*\n  Cache-Control: public, max-age=31536000, immutable\n");
 }
 
 // src/build/verified.ts
-async function buildVerified(siteRoot, output = join6(siteRoot, "dist"), origin, slug) {
+async function buildVerified(siteRoot, output = join8(siteRoot, "dist"), origin, slug) {
   if (isPreserveSite(siteRoot)) return buildPreservedSite(siteRoot, output);
-  const root = resolve2(siteRoot), out = resolve2(output);
+  const root = resolve3(siteRoot), out = resolve3(output);
   if (out === root || root.startsWith(out + sep2)) throw new Error("Build output cannot contain site source");
   for (const path of ["pages", "components", "theme", "media", "public", "agent", "onboarding"]) {
-    const source = join6(root, path);
+    const source = join8(root, path);
     if (out === source || out.startsWith(source + sep2)) throw new Error("Build output cannot overwrite source directories");
   }
   const stage = out + `.stage-${Date.now()}-${process.pid}`;
-  mkdirSync4(dirname4(stage), { recursive: true });
+  mkdirSync5(dirname5(stage), { recursive: true });
   const local = await loadSiteDir(root);
   if (slug) local.site = { ...local.site, slug };
-  const launch = existsSync6(join6(root, "launch.json")) ? json(join6(root, "launch.json")) : {};
+  const launch = existsSync8(join8(root, "launch.json")) ? json(join8(root, "launch.json")) : {};
   await buildSite({ ...local, webAnalyticsToken: launch.webAnalyticsToken, forms: launch.forms, kernelOrigin: origin || process.env.VITRIS_BACKEND_ORIGIN || process.env.KERNEL_ORIGIN || launch.backendOrigin || launch.kernelOrigin || "", publicOrigin: process.env.VITRIS_PUBLIC_ORIGIN || launch.publicOrigin, outDir: stage });
   for (const path of ["media", "public"]) {
     const source = within(root, path);
-    if (!existsSync6(source)) continue;
+    if (!existsSync8(source)) continue;
     files(source);
-    if (path === "media") cpSync2(source, join6(stage, path), { recursive: true });
+    if (path === "media") cpSync2(source, join8(stage, path), { recursive: true });
     else for (const file of files(source)) {
       const rel = file.slice(source.length + 1);
-      if (existsSync6(join6(stage, rel))) throw new Error(`Public asset conflicts with compiled output: ${rel}`);
-      mkdirSync4(dirname4(join6(stage, rel)), { recursive: true });
-      cpSync2(file, join6(stage, rel));
+      if (existsSync8(join8(stage, rel))) throw new Error(`Public asset conflicts with compiled output: ${rel}`);
+      mkdirSync5(dirname5(join8(stage, rel)), { recursive: true });
+      cpSync2(file, join8(stage, rel));
     }
   }
-  await responsiveMedia(stage, join6(root, ".vitris/cache/media"));
+  await responsiveMedia(stage, join8(root, ".vitris/cache/media"));
   finalizeStaticOutput(stage, process.env.VITRIS_PUBLIC_ORIGIN || launch.publicOrigin);
   const errors = [];
-  const storyboardPath = join6(root, "onboarding/storyboard.json");
-  if (existsSync6(storyboardPath)) {
+  const storyboardPath = join8(root, "onboarding/storyboard.json");
+  if (existsSync8(storyboardPath)) {
     const plan = json(storyboardPath);
-    const redirectPath = join6(stage, "_redirects");
-    let redirects = existsSync6(redirectPath) ? readFileSync6(redirectPath, "utf8") : "";
+    const redirectPath = join8(stage, "_redirects");
+    let redirects = existsSync8(redirectPath) ? readFileSync8(redirectPath, "utf8") : "";
     for (const route of plan.routes || []) {
       if (!["redirect", "consolidate"].includes(route.disposition) || !route.target) continue;
       const from = new URL(route.source).pathname.replace(/\/$/, "") || "/";
@@ -629,32 +717,39 @@ async function buildVerified(siteRoot, output = join6(siteRoot, "dist"), origin,
       if (!existing) redirects += `
 ${from} ${route.target} 301`;
     }
-    if (redirects.trim()) writeFileSync4(redirectPath, redirects.trim() + "\n");
+    if (redirects.trim()) writeFileSync5(redirectPath, redirects.trim() + "\n");
   }
   for (const file of files(stage).filter((p) => /\.(html|css)$/.test(p))) {
-    const content = readFileSync6(file, "utf8");
+    const content = readFileSync8(file, "utf8");
     const refs = file.endsWith(".html") ? [...content.matchAll(/(?:src|poster)=["']([^"']+)["']/g)].map((m) => m[1]) : [...content.matchAll(/url\(["']?([^)'"\s]+)["']?\)/g)].map((m) => m[1]);
     for (const ref of refs) {
       if (/^(https?:|data:|blob:|#|\/\/)/.test(ref)) continue;
       const path = ref.split(/[?#]/)[0];
-      const target = within(stage, path.startsWith("/") ? path.slice(1) : join6(dirname4(file).slice(stage.length + 1), path));
-      if (!existsSync6(target)) errors.push(`Missing asset ${ref} in ${file}`);
+      const target = within(stage, path.startsWith("/") ? path.slice(1) : join8(dirname5(file).slice(stage.length + 1), path));
+      if (!existsSync8(target)) errors.push(`Missing asset ${ref} in ${file}`);
     }
     if (file.endsWith(".html") && /<slot\b/.test(content)) errors.push(`Unresolved slots: ${file}`);
   }
   if (errors.length) throw new Error(errors.join("\n"));
-  save(join6(stage, "package-manifest.json"), { slug: local.site.slug || "", site: local.site });
-  const kernelParent = resolve2(import.meta.dirname, "..");
-  const kernelSource = existsSync6(join6(kernelParent, "compile")) ? kernelParent : join6(kernelParent, "src");
-  save(join6(stage, "build-evidence.json"), { version: 2, sourceHash: sourceHash(root), compilerHash: fingerprint(kernelSource, ["compile", "build", "runtime", "forms", "theme.ts"]) });
+  save(join8(stage, "package-manifest.json"), { slug: local.site.slug || "", site: local.site });
+  const kernelParent = resolve3(import.meta.dirname, "..");
+  const kernelSource = existsSync8(join8(kernelParent, "compile")) ? kernelParent : join8(kernelParent, "src");
+  save(join8(stage, "build-evidence.json"), { version: 2, sourceHash: sourceHash(root), compilerHash: fingerprint(kernelSource, ["compile", "build", "runtime", "forms", "theme.ts"]) });
   const previous = out + `.previous-${Date.now()}-${process.pid}`;
-  if (existsSync6(out)) replacePath(out, previous);
+  if (existsSync8(out)) replacePath(out, previous);
   try {
     replacePath(stage, out);
   } catch (error) {
-    if (existsSync6(previous)) replacePath(previous, out);
+    if (existsSync8(previous)) replacePath(previous, out);
     throw error;
   }
+  if (out === join8(root, "dist") && existsSync8(previous)) {
+    try {
+      archivePreviousBuild(root, previous);
+    } catch (error) {
+      console.warn(`Could not finish archiving previous build; inspect the previous-build and archive folders: ${String(error)}`);
+    }
+  }
 }
 
 export {
@@ -671,6 +766,8 @@ export {
   SUPPORTED_REACT_BLOCKS,
   unresolvedCaptureBlockers,
   pageFile,
+  findHarnessRoot,
+  findKernelRoot,
   preserveRuntime,
   preserveManifest,
   buildPreservedSite,

package/bin/chunks/{chunk-DRJQ4OOU.js → chunk-WOORR67N.js}

@@ -376,46 +376,6 @@ ${proposal}`,
     CREATIVE_SCORE_RUBRICS
   );
 }
-var COMPONENT_FIT_RUBRICS = [
-  { score: 0, description: "Fail: incompatible with this dimension." },
-  { score: 1, description: "Weak fit; would need heavy adaptation." },
-  { score: 2, description: "Usable starting point with documented adaptations." },
-  { score: 3, description: "Strong fit on this dimension from metadata alone." },
-  { score: 4, description: "Excellent fit; little adaptation required." }
-];
-function makeComponentFitQuestion(dimension, candidate, state) {
-  return score(
-    `Score "${dimension}" for this block using only the supplied textual metadata. Jev has not seen pixels or screenshots.
-
-Section state:
-${state}
-
-Candidate:
-${candidate}`,
-    COMPONENT_FIT_RUBRICS
-  );
-}
-function makeRhythmRepetitionQuestion(pageRhythm, candidate) {
-  return noul(
-    `Would reusing this block create repetitive page rhythm relative to adjacent sections?
-
-Adjacent / page rhythm:
-${pageRhythm}
-
-Candidate:
-${candidate}`,
-    {
-      true: "Reuse would create repetitive page rhythm.",
-      false: "Reuse would not create repetitive page rhythm."
-    }
-  );
-}
-var COMPONENT_FIT_TASK_SEMANTICS = {
-  version: QUESTION_VERSION,
-  primitive: "score+noul",
-  rubrics: COMPONENT_FIT_RUBRICS
-};
-var COMPONENT_FIT_SEMANTICS_HASH = questionSemanticsHash(COMPONENT_FIT_TASK_SEMANTICS);
 var DIRECTION_DECISION_CRITERIA = {
   supports: "The textual proposal supports this check.",
   contradicts: "The textual proposal conflicts with this check.",
@@ -501,11 +461,6 @@ export {
   makeRedundancyNoulQuestion,
   CREATIVE_SCORE_RUBRICS,
   makeCreativeDimensionQuestion,
-  COMPONENT_FIT_RUBRICS,
-  makeComponentFitQuestion,
-  makeRhythmRepetitionQuestion,
-  COMPONENT_FIT_TASK_SEMANTICS,
-  COMPONENT_FIT_SEMANTICS_HASH,
   DIRECTION_DECISION_CRITERIA,
   DIRECTION_DECISION_CHECKS,
   makeDirectionDecisionQuestion,