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

package/bin/chunks/chunk-4DM5TTLG.js

@@ -0,0 +1,219 @@
+import {
+  stripAgentRuntimeHistory
+} from "./chunk-34H54KEY.js";
+import {
+  EXIT_CODES
+} from "./chunk-JCRGE6AL.js";
+import {
+  gatherBlankOnboard,
+  persistOnboard
+} from "./chunk-Z2UNY47A.js";
+import {
+  persistSiteInputs,
+  recordManagedKit,
+  resolveSiteInputs
+} from "./chunk-3CTBXY5K.js";
+import {
+  initialState,
+  parseGraphYaml
+} from "./chunk-BBV7PMFC.js";
+import {
+  findHarnessRoot
+} from "./chunk-HNORQ74T.js";
+import {
+  save
+} from "./chunk-T6PE4KN4.js";
+
+// src/cli/site-create.ts
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+var harnessRoot = findHarnessRoot();
+async function createSite(opts) {
+  const dir = opts.dir;
+  const slug = (opts.slug || "").toLowerCase().replace(/[^a-z0-9-]/g, "");
+  const name = opts.name || slug;
+  const fromArg = opts.from;
+  const blank = !!opts.blank;
+  const mode = opts.mode || "redesign";
+  const ownerEmail = opts.owner || "";
+  const backendOrigin = (opts.backendOrigin || opts.kernelOrigin || "").replace(/\/$/, "");
+  const harnessSpec = opts.harnessSpec || opts.kernelSpec || JSON.parse(readFileSync(join(harnessRoot, "package.json"), "utf8")).version;
+  if (!dir || !slug) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "createSite requires --dir and --slug"
+    };
+  }
+  if (!["redesign", "preserve"].includes(mode) || mode === "preserve" && (!fromArg || blank)) {
+    return { ok: false, exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR, error: "Use --mode redesign|preserve. Preserve mode requires --from URL and cannot use --blank." };
+  }
+  if (mode === "preserve") {
+    try {
+      const url = new URL(fromArg);
+      if (!/^https?:$/.test(url.protocol) || url.username || url.password) throw new Error();
+    } catch {
+      return { ok: false, exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR, error: "Preserve --from must be an HTTP(S) URL without credentials" };
+    }
+  }
+  if (blank && fromArg) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR,
+      error: "Use either --from or --blank, not both"
+    };
+  }
+  let inputs;
+  try {
+    inputs = resolveSiteInputs(opts);
+    if (mode === "preserve" && (inputs.template || inputs.content !== void 0)) throw Error("Template and additional content inputs require redesign mode");
+  } catch (error) {
+    return { ok: false, exitCode: EXIT_CODES.CONFIG_OR_CLI_ERROR, error: error instanceof Error ? error.message : String(error) };
+  }
+  const dest = resolve(dir);
+  if (existsSync(dest) && existsSync(join(dest, "package.json")) && !opts.force) {
+    return {
+      ok: false,
+      exitCode: EXIT_CODES.PRECONDITION_FAILED,
+      error: `Refusing to overwrite existing package.json in ${dest}. Pass --force to override.`
+    };
+  }
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      exitCode: EXIT_CODES.SUCCESS,
+      summary: `[dry-run] Would scaffold site ${slug} (${name}) at ${dest}`,
+      data: { dest, slug, name }
+    };
+  }
+  mkdirSync(dest, { recursive: true });
+  cpSync(join(harnessRoot, "templates", "site"), dest, { recursive: true });
+  renameSync(join(dest, "gitignore"), join(dest, ".gitignore"));
+  cpSync(join(harnessRoot, "agent"), join(dest, "agent"), { recursive: true });
+  stripAgentRuntimeHistory(join(dest, "agent"));
+  recordManagedKit(dest, harnessRoot);
+  mkdirSync(join(dest, "design-system"), { recursive: true });
+  cpSync(join(harnessRoot, "design-system", "MASTER.md"), join(dest, "design-system", "MASTER.md"));
+  const pkgPath = join(dest, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  pkg.name = slug;
+  pkg.dependencies["@tryvitris/website-harness"] = harnessSpec;
+  if (mode === "preserve") {
+    pkg.scripts.go = "node ./node_modules/@tryvitris/website-harness/bin/vitris.js run --site .";
+    pkg.scripts.eval = "node ./node_modules/@tryvitris/website-harness/bin/vitris.js verify --site .";
+    pkg.scripts.deploy = "node ./node_modules/@tryvitris/website-harness/bin/vitris.js deploy --site . --environment preview";
+    pkg.scripts["verify:browser"] = pkg.scripts.eval;
+  }
+  for (const [key, value] of Object.entries(pkg.scripts)) pkg.scripts[key] = value.replaceAll("__SLUG__", slug);
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  for (const file of ["site.json", "README.md", "AGENTS.md"]) {
+    const p = join(dest, file);
+    if (file === "site.json" && existsSync(p)) {
+      const site = JSON.parse(readFileSync(p, "utf8"));
+      site.slug = slug;
+      site.name = name;
+      site.siteId = site.siteId || randomUUID();
+      site.sourceFormatVersion = 1;
+      site.capabilities = backendOrigin ? ["analytics"] : [];
+      writeFileSync(p, `${JSON.stringify(site, null, 2)}
+`);
+    } else if (existsSync(p)) {
+      writeFileSync(p, readFileSync(p, "utf8").replaceAll("__SLUG__", slug).replaceAll("__NAME__", name));
+    }
+  }
+  const launchPath = join(dest, "launch.json");
+  const launch = existsSync(launchPath) ? JSON.parse(readFileSync(launchPath, "utf8")) : {};
+  launch.slug = slug;
+  launch.name = name;
+  launch.sourceUrl = fromArg || "";
+  launch.mode = mode;
+  if (mode === "redesign") {
+    launch.themeSelection = { version: 1, enabled: true };
+    launch.templateAdaptation = { version: 2 };
+  }
+  launch.backendOrigin = backendOrigin;
+  launch.forms = launch.forms || [];
+  launch.ownerEmail = ownerEmail;
+  launch.pagesProject = slug;
+  launch.github = { owner: "", repo: "" };
+  launch.publicOrigin = "";
+  writeFileSync(launchPath, `${JSON.stringify(launch, null, 2)}
+`);
+  if (mode === "preserve") {
+    writeFileSync(join(dest, "README.md"), `# ${name}
+
+Preserved custom website from ${fromArg}.
+
+1. npm install
+2. npx playwright install chromium
+3. npm run go
+4. npm run preview
+5. npm run deploy (temporary Cloudflare preview)
+
+Custom source: preserved/. Verification: agent/reviews/preserve.json. See AGENTS.md and the installed harness docs/PRESERVE.md. Run vitris forms inspect and vitris forms setup to register and connect contact forms; backendOrigin alone does not enable submission or notifications. See docs/CONTACT-FORMS.md.
+`);
+    writeFileSync(join(dest, "AGENTS.md"), `# ${name} preservation
+
+Run npm run go to capture and verify the existing client-facing site. Keep its appearance, copy, routes, and interactions. Custom HTML, CSS, assets, and runtime live in preserved/. No redesign, design-system injection, or creative graph is used while launch.json mode is preserve.
+
+Repair source in preserved/ when agent/reviews/preserve.json reports a failure; run npm run go again. Never change reference screenshots or hashes to make a check pass. Do not overwrite source by recapturing. onboarding/preserve.json records the source and captured routes. Contact forms require explicit registration and public launch.json forms bindings. backendOrigin alone does not enable delivery. Default previews show a notice without submitting. See docs/CONTACT-FORMS.md.
+
+Use npm run deploy for a temporary Cloudflare preview after verification. Production and customer domains are outside this mode. Scaffold a later redesign separately from the same source URL.
+`);
+  }
+  const workflow = join(dest, ".github", "workflows", "deploy.yml");
+  if (existsSync(workflow)) {
+    if (mode === "preserve") {
+      writeFileSync(workflow, `name: Preserve preview
+on: workflow_dispatch
+jobs:
+  preview:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - run: npm ci
+      - run: npx playwright install --with-deps chromium
+      - run: npm run deploy
+        env:
+          CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+`);
+    } else writeFileSync(workflow, readFileSync(workflow, "utf8").replaceAll("__SLUG__", slug));
+  }
+  const gathered = await gatherBlankOnboard({ slug, name, noPrompt: true });
+  gathered.brief.sourceUrl = fromArg || "";
+  if (fromArg) {
+    gathered.brief.warnings = [
+      "Harvest pending \u2014 from this site repo: npm install && npx playwright install chromium && npm run go (or npm run harvest)."
+    ];
+  }
+  persistOnboard(dest, gathered.brief, {
+    pages: gathered.pages,
+    copyMarkdown: gathered.copyMarkdown
+  });
+  persistSiteInputs(dest, inputs);
+  const graphPath = join(dest, "agent", "graph.yaml");
+  if (existsSync(graphPath)) {
+    const graph = parseGraphYaml(readFileSync(graphPath, "utf8"));
+    const state = initialState(graph);
+    if (!fromArg && state.nodes.harvest) {
+      state.nodes.harvest = { status: "done", attempts: 0 };
+    }
+    save(join(dest, "agent", "STATE.json"), state);
+  }
+  return {
+    ok: true,
+    exitCode: EXIT_CODES.SUCCESS,
+    summary: `Created site ${slug} at ${dest}`,
+    data: { dest, slug, name }
+  };
+}
+
+export {
+  createSite
+};

package/bin/chunks/chunk-4GZCAWWK.js

@@ -0,0 +1,327 @@
+import {
+  parseFrontmatter
+} from "./chunk-ANMJRJQ5.js";
+import {
+  COOKIE_COMPLIANCE_PATH,
+  beaconJs,
+  compileAllPages,
+  compileSite,
+  defaultTitleFromPath,
+  fileToPath,
+  motionAssetHref,
+  motionJs,
+  robotsTxt,
+  siteCss,
+  siteIslands,
+  sitemapXml
+} from "./chunk-YCVGD2CG.js";
+import {
+  mergeTheme,
+  themeCss
+} from "./chunk-LKN75JGA.js";
+import {
+  escapeHtml
+} from "./chunk-7FS67SRF.js";
+
+// src/build/index.ts
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { createHash } from "node:crypto";
+
+// src/forms/frontend.ts
+import { parseFragment } from "parse5";
+
+// src/forms/config.ts
+var safeId = (s) => typeof s === "string" && /^[a-zA-Z0-9_-]{1,80}$/.test(s);
+var safeEmail = (s) => {
+  if (typeof s !== "string" || s.length > 254 || !/^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,63}$/.test(s)) return false;
+  const [local, domain] = s.split("@");
+  return !!local && local.length <= 64 && !local.startsWith(".") && !local.endsWith(".") && !local.includes("..") && !!domain && domain.split(".").every((label) => label.length <= 63 && /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/.test(label));
+};
+function approvedOrigin(value) {
+  const u = new URL(value);
+  if (u.origin !== value || u.hostname.includes("*") || u.username || u.password || u.protocol !== "https:" && !(u.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname))) throw new Error("Expected exact HTTPS origin (HTTP only on loopback)");
+  return u.origin;
+}
+function validateFormConfig(value) {
+  const c = value;
+  if (!c || !safeId(c.id) || !["disabled", "test", "live"].includes(c.mode)) throw new Error("Invalid form ID or mode");
+  if (!Array.isArray(c.origins) || !c.origins.length || c.origins.length > 10 || new Set(c.origins).size !== c.origins.length) throw new Error("One to ten unique exact origins required");
+  c.origins.forEach(approvedOrigin);
+  if (c.mode === "live" && c.origins.some((o) => new URL(o).protocol !== "https:" || ["localhost", "127.0.0.1", "[::1]"].includes(new URL(o).hostname))) throw new Error("Live forms cannot approve loopback origins");
+  if (!Array.isArray(c.fields) || !c.fields.length || c.fields.length > 32 || new Set(c.fields.map((f) => f.name)).size !== c.fields.length) throw new Error("One to 32 unique fields required");
+  const reserved = /* @__PURE__ */ new Set(["form_id", "tenant_id", "idempotency_key", "page_path", "vid", "company_url", "cf-turnstile-response", "recipients", "to", "from", "sender"]);
+  const maps = /* @__PURE__ */ new Set();
+  for (const f of c.fields) {
+    if (!safeId(f.name) || reserved.has(f.name) || !["text", "email", "tel", "textarea", "select", "checkbox", "radio"].includes(f.type) || !Number.isInteger(f.maxLength) || f.maxLength < 1 || f.maxLength > 8e3 || f.minLength !== void 0 && (!Number.isInteger(f.minLength) || f.minLength < 0 || f.minLength > f.maxLength) || f.label !== void 0 && (typeof f.label !== "string" || f.label.length > 200) || f.required !== void 0 && typeof f.required !== "boolean") throw new Error("Invalid field schema");
+    if (f.map !== void 0) {
+      if (!["name", "email", "phone", "message"].includes(f.map) || maps.has(f.map)) throw new Error("Invalid or duplicate mapping");
+      maps.add(f.map);
+    }
+    if ((["select", "checkbox", "radio"].includes(f.type) || f.options !== void 0) && (!Array.isArray(f.options) || !f.options.length || f.options.length > 40 || f.options.some((s) => typeof s !== "string" || !s || s.length > f.maxLength) || new Set(f.options).size !== f.options.length)) throw new Error("Choice fields need bounded options");
+  }
+  if (!c.fields.some((f) => f.map === "email" && f.type === "email" && f.required)) throw new Error("A required visitor email mapping is needed");
+  if (!Array.isArray(c.recipients) || c.recipients.length > 5 || c.recipients.some((r) => !safeEmail(r)) || new Set(c.recipients).size !== c.recipients.length) throw new Error("Invalid notification recipients");
+  if (!c.turnstile || typeof c.turnstile.sitekey !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(c.turnstile.sitekey) || !safeId(c.turnstile.secretRef) || !safeId(c.turnstile.action) || c.turnstile.action.length > 32) throw new Error("Invalid Turnstile configuration");
+  return c;
+}
+
+// src/forms/frontend.ts
+function inspectForms(html) {
+  const inventory = [];
+  const walk = (node, visit) => {
+    if ("tagName" in node) visit(node);
+    if ("childNodes" in node) node.childNodes.forEach((n) => walk(n, visit));
+  };
+  walk(parseFragment(html), (form) => {
+    if (form.tagName !== "form") return;
+    const fields = [], unsupported = [];
+    let eligible = form.attrs.some((a) => a.name === "data-lead-form");
+    if (form.attrs.some((a) => ["data-lead-custom", "data-no-enhance"].includes(a.name))) unsupported.push("Custom submission handler needs explicit migration");
+    walk(form, (el) => {
+      const attr = (name2) => el.attrs.find((a) => a.name === name2)?.value;
+      if (attr("data-vitrisid") === "emailSendButton") eligible = true;
+      if (!["input", "textarea", "select"].includes(el.tagName)) return;
+      const name = attr("name"), type = el.tagName === "input" ? attr("type") || "text" : el.tagName;
+      if (["hidden", "submit", "button", "reset"].includes(type)) {
+        if (type === "hidden" && name && !["vid", "page_path", "company_url", "form_id", "tenant_id", "idempotency_key", "cf-turnstile-response"].includes(name)) unsupported.push(`Unmapped hidden field: ${name}`);
+        return;
+      }
+      if (!name || !safeId(name) || !["text", "email", "tel", "textarea", "select", "checkbox", "radio"].includes(type)) {
+        unsupported.push(`Unsupported field: ${name || "(unnamed)"} (${type})`);
+        return;
+      }
+      if (attr("multiple") !== void 0 && type !== "checkbox") unsupported.push(`Unsupported multiple field: ${name}`);
+      const options = [];
+      if (type === "select") walk(el, (opt) => {
+        if (opt.tagName === "option") {
+          const value = opt.attrs.find((a) => a.name === "value")?.value ?? opt.childNodes.filter((n) => "value" in n).map((n) => n.value).join("");
+          if (value) options.push(value);
+        }
+      });
+      if (type === "checkbox" || type === "radio") options.push(attr("value") || "on");
+      const old = fields.find((f) => f.name === name);
+      if (old) {
+        if (old.type === type && ["checkbox", "radio"].includes(type)) {
+          old.options.push(...options);
+          old.required = old.required || attr("required") !== void 0;
+        } else unsupported.push(`Duplicate field: ${name}`);
+        return;
+      }
+      fields.push({ name, type, label: attr("aria-label") || name, required: attr("required") !== void 0, minLength: Number(attr("minlength") || 0), maxLength: Math.min(8e3, Number(attr("maxlength") || (type === "textarea" ? 8e3 : 255))), ...["select", "checkbox", "radio"].includes(type) ? { options } : {}, ...["name", "email", "message", "phone"].includes(name) ? { map: name } : ["number", "telephone", "phone_number", "phoneNumber"].includes(name) ? { map: "phone" } : {} });
+    });
+    inventory.push({ index: inventory.length, eligible, fields, unsupported });
+  });
+  return inventory;
+}
+function connectForms(html, backend, pagePath, forms) {
+  const bindings = forms.filter((f) => f.pagePath === pagePath);
+  if (!bindings.length) return html;
+  approvedOrigin(backend);
+  const inventory = inspectForms(html);
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of bindings) {
+    const index = f.index ?? 0, item = inventory[index];
+    if (!safeId(f.id) || !safeId(f.action) || f.action.length > 32 || !/^[a-zA-Z0-9_-]{1,100}$/.test(f.sitekey) || !item || !item.eligible || item.unsupported.length || seen.has(index)) throw new Error(`Cannot connect ${pagePath} form ${index}: ${item?.unsupported.join(", ") || "explicit contact-form marker and valid unique binding required"}`);
+    seen.add(index);
+  }
+  const located = [];
+  const walk = (node) => {
+    if ("tagName" in node && node.tagName === "form") located.push(node);
+    if ("childNodes" in node) node.childNodes.forEach(walk);
+  };
+  walk(parseFragment(html, { sourceCodeLocationInfo: true }));
+  const edits = [];
+  for (const binding of bindings) {
+    const form = located[binding.index ?? 0], location = form.sourceCodeLocation;
+    if (!location?.startTag || !location.endTag) throw new Error("Unclosed contact form requires source repair");
+    const start = location.startTag.startOffset, end = location.endTag.endOffset;
+    let open = html.slice(start, location.startTag.endOffset);
+    const remove = /* @__PURE__ */ new Set(["action", "method", "novalidate", "data-preserve-forms", "data-vitris-form", "data-vitris-sitekey", "data-vitris-action", "data-vitris-enhanced", "data-lead-form"]);
+    for (const [name, span] of Object.entries(location.attrs || {}).sort((a, b) => b[1].startOffset - a[1].startOffset)) if (remove.has(name)) open = open.slice(0, span.startOffset - start) + open.slice(span.endOffset - start);
+    let inner = html.slice(location.startTag.endOffset, location.endTag.startOffset);
+    const inputs = [];
+    const collect = (node) => {
+      if ("tagName" in node && node.tagName === "input") inputs.push(node);
+      if ("childNodes" in node) node.childNodes.forEach(collect);
+    };
+    collect(form);
+    for (const input of inputs.sort((a, b) => (b.sourceCodeLocation?.startOffset || 0) - (a.sourceCodeLocation?.startOffset || 0))) {
+      const name = input.attrs.find((a) => a.name === "name")?.value;
+      if (["form_id", "idempotency_key", "cf-turnstile-response"].includes(name || "") && input.sourceCodeLocation) {
+        const s = input.sourceCodeLocation.startOffset - location.startTag.endOffset, e = input.sourceCodeLocation.endOffset - location.startTag.endOffset;
+        inner = inner.slice(0, s) + inner.slice(e);
+      }
+    }
+    const has = (name) => inputs.some((input) => input.attrs.some((a) => a.name === "name" && a.value === name));
+    open = open.replace(/>$/, ` method="post" action="${escapeHtml(backend)}/api/leads?form_id=${binding.id}" data-lead-form data-vitris-enhanced data-preserve-forms="live" data-vitris-form="${binding.id}" data-vitris-sitekey="${binding.sitekey}" data-vitris-action="${binding.action}">`);
+    const value = `${open}<input type="hidden" name="form_id" value="${binding.id}">${has("page_path") ? "" : `<input type="hidden" name="page_path" value="${escapeHtml(pagePath)}">`}${has("company_url") ? "" : '<input type="hidden" name="company_url" value="">'}${inner}<noscript><p>This form needs JavaScript and a security check. Please use the listed contact details.</p></noscript>${html.slice(location.endTag.startOffset, end)}`;
+    edits.push({ start, end, value });
+  }
+  for (const edit of edits.sort((a, b) => b.start - a.start)) html = html.slice(0, edit.start) + edit.value + html.slice(edit.end);
+  return html;
+}
+
+// src/build/index.ts
+async function walkHtmlFiles(dir, base = dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await walkHtmlFiles(full, base));
+    } else if (entry.isFile() && entry.name.endsWith(".html")) {
+      out.push(relative(base, full).replace(/\\/g, "/"));
+    }
+  }
+  return out;
+}
+async function loadSiteCatalog(siteDir) {
+  const catalog = {};
+  try {
+    const entries = await readdir(join(siteDir, "components"), { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const name = String(entry.name);
+      const dir = join(siteDir, "components", name);
+      let html;
+      let css;
+      try {
+        html = await readFile(join(dir, "template.html"), "utf8");
+        css = await readFile(join(dir, "styles.css"), "utf8");
+      } catch {
+        continue;
+      }
+      let island = null;
+      try {
+        island = await readFile(join(dir, "island.js"), "utf8");
+      } catch {
+        island = null;
+      }
+      catalog[name] = { html, css, island };
+    }
+  } catch {
+    return catalog;
+  }
+  return catalog;
+}
+async function loadSitePages(siteDir) {
+  const pagesDir = join(siteDir, "pages");
+  const files = await walkHtmlFiles(pagesDir);
+  const pages = [];
+  for (const file of files.sort()) {
+    const raw = await readFile(join(pagesDir, file), "utf8");
+    const { meta, body } = parseFrontmatter(raw);
+    const path = fileToPath(file);
+    pages.push({
+      path,
+      file,
+      title: meta.title || defaultTitleFromPath(path),
+      description: meta.description,
+      indexing: path === "/404" ? "noindex" : meta.indexing === "noindex" || meta.indexing === "index" ? meta.indexing : void 0,
+      lang: meta.lang,
+      body
+    });
+  }
+  return pages;
+}
+async function loadSiteDir(dir) {
+  const site = JSON.parse(await readFile(join(dir, "site.json"), "utf8"));
+  let theme = {};
+  try {
+    theme = JSON.parse(await readFile(join(dir, "theme", "defaults.json"), "utf8"));
+  } catch {
+    theme = {};
+  }
+  const pages = await loadSitePages(dir);
+  const catalog = await loadSiteCatalog(dir);
+  return { site, theme, pages, catalog };
+}
+async function buildSite(input) {
+  const backendOrigin = input.backendOrigin || input.kernelOrigin || "";
+  const theme = mergeTheme(input.theme);
+  const themeHref = input.themeHref ?? "/theme.css";
+  const envName = process.env.VITRIS_SITE_ENVIRONMENT;
+  const site = envName === "preview" || envName === "production" ? { ...input.site, environment: envName } : input.site;
+  const compiled = compileAllPages(site, input.pages, input.catalog, backendOrigin);
+  const pageAssets = {};
+  const routeAssets = /* @__PURE__ */ new Map();
+  const asset = (body, ext) => {
+    const path = `/assets/immutable/${createHash("sha256").update(body).digest("hex")}.${ext}`;
+    routeAssets.set(path, body);
+    return path;
+  };
+  for (const page of compiled) {
+    const js = siteIslands([page], input.catalog);
+    pageAssets[page.path] = { css: asset(siteCss([page], input.catalog), "css"), js: js ? asset(js, "js") : null };
+  }
+  const files = compileSite({
+    site,
+    pages: input.pages,
+    catalog: input.catalog,
+    kernelOrigin: backendOrigin,
+    themeHref,
+    publicOrigin: input.publicOrigin,
+    pageAssets,
+    webAnalyticsToken: input.webAnalyticsToken
+  });
+  const written = [];
+  await mkdir(input.outDir, { recursive: true });
+  await mkdir(join(input.outDir, "assets/immutable"), { recursive: true });
+  for (const [path, body] of routeAssets) await writeFile(join(input.outDir, path.slice(1)), body, "utf8");
+  for (const file of files) {
+    const rel = file.path === "/" ? "index.html" : `${file.path.replace(/^\//, "").replace(/\/$/, "")}/index.html`;
+    const dest = join(input.outDir, rel);
+    await mkdir(join(dest, ".."), { recursive: true });
+    await writeFile(dest, connectForms(file.html, backendOrigin, file.path, input.forms || []), "utf8");
+    written.push(rel);
+  }
+  await writeFile(join(input.outDir, "site.css"), siteCss(compiled, input.catalog), "utf8");
+  await writeFile(join(input.outDir, "theme.css"), themeCss(theme), "utf8");
+  if (backendOrigin) await writeFile(join(input.outDir, "beacon.js"), beaconJs, "utf8");
+  await writeFile(join(input.outDir, "robots.txt"), robotsTxt(input.publicOrigin), "utf8");
+  await writeFile(
+    join(input.outDir, "sitemap.xml"),
+    sitemapXml(
+      compiled.map((p) => p.path),
+      input.publicOrigin,
+      [COOKIE_COMPLIANCE_PATH, ...site.indexing === "noindex" ? compiled.map((page) => page.path) : compiled.filter((page) => page.indexing === "noindex").map((page) => page.path)],
+      Boolean(backendOrigin)
+    ),
+    "utf8"
+  );
+  const islands = siteIslands(compiled, input.catalog);
+  if (islands) await writeFile(join(input.outDir, "islands.js"), islands, "utf8");
+  if (compiled.some((page) => page.usesMotion)) {
+    await writeFile(join(input.outDir, motionAssetHref.slice(1)), motionJs, "utf8");
+    written.push(motionAssetHref.slice(1));
+  }
+  if (islands) written.push("islands.js");
+  written.push("site.css", "theme.css", "beacon.js", "robots.txt", "sitemap.xml");
+  return written;
+}
+async function fetchLiveContent(kernelOrigin, slug, token) {
+  const res = await fetch(`${kernelOrigin.replace(/\/$/, "")}/api/deploy/${encodeURIComponent(slug)}`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) return null;
+  return await res.json();
+}
+
+export {
+  safeId,
+  approvedOrigin,
+  validateFormConfig,
+  inspectForms,
+  connectForms,
+  loadSiteCatalog,
+  loadSitePages,
+  loadSiteDir,
+  buildSite,
+  fetchLiveContent
+};