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

package/bin/chunks/chunk-54JC5L35.js

@@ -0,0 +1,493 @@
+import {
+  acceptVerifiedRefine,
+  attribute,
+  changedSourceFiles,
+  elementMatchesIdentity,
+  prepareRefine,
+  sourceRevision,
+  verifyRefine,
+  withMutationLock
+} from "./chunk-3CTBXY5K.js";
+import {
+  assertRequestId,
+  parseChangePlan,
+  parseChangeRequest,
+  parseSiteIdentity
+} from "./chunk-M4LNHYYR.js";
+import {
+  buildVerified
+} from "./chunk-E5Y46VBX.js";
+import {
+  findHarnessRoot
+} from "./chunk-HNORQ74T.js";
+import {
+  files,
+  fingerprint,
+  json,
+  recoverableReplace,
+  save,
+  within
+} from "./chunk-T6PE4KN4.js";
+
+// src/engine/index.ts
+import { createHash, randomUUID } from "node:crypto";
+import { cpSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+import { parseFragment as parseFragment3 } from "parse5";
+
+// src/editing/manifest.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { parseFragment } from "parse5";
+var attr = (node, name) => attribute(node.attrs, name);
+function generateEditManifest(siteRoot) {
+  const root = resolve(siteRoot);
+  const fields = [];
+  const movableSections = [];
+  for (const folder of ["pages", "components"]) {
+    const base = join(root, folder);
+    for (const file of files(base).filter((path) => path.endsWith(".html"))) {
+      const sourceFile = relative(root, file).replaceAll("\\", "/");
+      const route = folder === "pages" ? `/${relative(base, file).replaceAll("\\", "/").replace(/(?:\/)?index\.html$/, "").replace(/\.html$/, "")}`.replace(/\/$/, "") || "/" : void 0;
+      const schemaPath = folder === "components" ? join(dirname(file), "edit.schema.json") : "";
+      const declared = schemaPath && existsSync(schemaPath) ? new Set(JSON.parse(readFileSync(schemaPath, "utf8")).fields?.map((field) => field.id) || []) : void 0;
+      const tree = parseFragment(readFileSync(file, "utf8"));
+      const walk = (node, sectionId) => {
+        const id = attr(node, "id");
+        const section = node.nodeName === "section" && id ? id : sectionId;
+        if (route && node.nodeName === "section" && id && attr(node, "data-vitris-movable") !== void 0) movableSections.push({ route, id, sourceFile });
+        const fieldId = attr(node, "data-vitris-field");
+        const editable = folder === "pages" || Boolean(declared?.has(fieldId || ""));
+        if (fieldId && editable) {
+          const kind = node.nodeName === "img" ? "media" : node.childNodes?.length === 1 && node.childNodes[0]?.nodeName === "#text" ? "text" : void 0;
+          if (kind) fields.push({
+            id: fieldId,
+            ...route ? { route } : {},
+            ...section ? { sectionId: section } : {},
+            kind,
+            scope: folder === "pages" ? "instance" : "shared",
+            sourceFile,
+            elementId: fieldId
+          });
+        }
+        for (const child of node.childNodes || []) walk(child, section);
+      };
+      walk(tree);
+    }
+  }
+  const tokenSchema = join(root, "theme/edit.schema.json");
+  const themeTokens = existsSync(tokenSchema) ? JSON.parse(readFileSync(tokenSchema, "utf8")).tokens || [] : [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    const key = `${field.sourceFile}#${field.id}`;
+    if (seen.has(key)) throw new Error(`Duplicate editable field ${key}`);
+    seen.add(key);
+  }
+  const manifest = {
+    schemaVersion: 1,
+    sourceRevision: sourceRevision(root).digest,
+    fields: fields.sort((a, b) => `${a.sourceFile}#${a.id}`.localeCompare(`${b.sourceFile}#${b.id}`)),
+    movableSections,
+    themeTokens
+  };
+  save(join(root, "agent/edit-manifest.json"), manifest);
+  return manifest;
+}
+function publicEditManifest(manifest) {
+  return {
+    schemaVersion: 1,
+    sourceRevision: manifest.sourceRevision,
+    fields: manifest.fields.map(({ id, route, sectionId, kind, scope }) => ({ id, route, sectionId, kind, scope })),
+    movableSections: manifest.movableSections.map(({ route, id }) => ({ route, id })),
+    themeTokens: manifest.themeTokens
+  };
+}
+
+// src/engine/checks.ts
+var REGISTERED_CHANGE_CHECKS = /* @__PURE__ */ new Set(["build", "render-375", "render-1080"]);
+
+// src/engine/impact.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { parseFragment as parseFragment2 } from "parse5";
+function maskTargetText(html, ids) {
+  const tree = parseFragment2(html, { sourceCodeLocationInfo: true });
+  const replacements = [];
+  const found = new Map(ids.map((id) => [id, 0]));
+  const walk = (node) => {
+    for (const id of ids) {
+      if (!elementMatchesIdentity(node.attrs, id)) continue;
+      found.set(id, (found.get(id) || 0) + 1);
+      const children = node.childNodes || [];
+      if (children.length !== 1 || children[0]?.nodeName !== "#text" || !children[0].sourceCodeLocation) return;
+      replacements.push({ start: children[0].sourceCodeLocation.startOffset, end: children[0].sourceCodeLocation.endOffset });
+    }
+    for (const child of node.childNodes || []) walk(child);
+  };
+  walk(tree);
+  if (ids.some((id) => found.get(id) !== 1) || replacements.length !== ids.length) return void 0;
+  return replacements.sort((a, b) => b.start - a.start).reduce((text, item) => text.slice(0, item.start) + "__VITRIS_PLANNED_TEXT__" + text.slice(item.end), html);
+}
+function copyImpactFailures(root, requestId, plan, changedFiles) {
+  if (plan.facets.length !== 1 || plan.facets[0] !== "copy" || plan.acceptanceCriteria.some((item) => item.kind !== "exact_text")) return [];
+  const ids = plan.targets.map((target) => target.split("#")[1]).filter((id) => Boolean(id));
+  if (!ids.length) return ["Exact copy plan has no route#field target for source impact validation"];
+  const failures = [];
+  for (const file of changedFiles) {
+    if (!file.endsWith(".html")) {
+      failures.push(`Exact copy plan changed unrelated source file ${file}`);
+      continue;
+    }
+    const backup = join2(root, `agent/requests/${requestId}/source-backup`, file);
+    if (!existsSync2(backup)) {
+      failures.push(`Exact copy plan has no baseline for ${file}`);
+      continue;
+    }
+    const before = readFileSync2(backup, "utf8"), after = readFileSync2(join2(root, file), "utf8");
+    const applicable = ids.filter((id) => before.includes(id) || after.includes(id));
+    const maskedBefore = maskTargetText(before, applicable), maskedAfter = maskTargetText(after, applicable);
+    if (maskedBefore === void 0 || maskedAfter === void 0 || maskedBefore !== maskedAfter) {
+      failures.push(`Unplanned source impact inside ${file}; exact copy plan permits only named field text`);
+    }
+  }
+  return failures;
+}
+
+// src/engine/index.ts
+function inspectSite(siteRoot) {
+  const root = resolve2(siteRoot);
+  const site = json(within(root, "site.json"));
+  const harness = json(join3(findHarnessRoot(), "package.json"));
+  const siteId = typeof site.siteId === "string" && site.siteId ? site.siteId : `legacy:${String(site.slug || "unknown")}`;
+  const identity = parseSiteIdentity({
+    schemaVersion: 1,
+    siteId,
+    sourceFormatVersion: typeof site.sourceFormatVersion === "number" ? site.sourceFormatVersion : 1,
+    harness: { name: "@tryvitris/website-harness", version: harness.version },
+    capabilities: Array.isArray(site.capabilities) ? site.capabilities : []
+  });
+  const pendingPath = join3(root, "agent/refine-pending.json");
+  const pending = existsSync3(pendingPath) ? json(pendingPath) : void 0;
+  return {
+    identity,
+    revision: sourceRevision(root),
+    legacyIdentity: !site.siteId,
+    ...pending?.requestId ? { pendingRequestId: pending.requestId } : {}
+  };
+}
+var digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+function prepareChange(siteRoot, rawRequest, rawPlan) {
+  const root = resolve2(siteRoot);
+  const request = parseChangeRequest(rawRequest);
+  const plan = parseChangePlan(rawPlan);
+  if (request.id !== plan.requestId || request.baseRevision !== plan.baseRevision) throw new Error("Request and plan identities differ");
+  if (!request.requestedScopes.every((scope) => plan.facets.includes(scope))) throw new Error("Plan omits an explicitly requested facet");
+  const unknownChecks = plan.requiredChecks.filter((id) => !REGISTERED_CHANGE_CHECKS.has(id));
+  if (unknownChecks.length) throw new Error(`Unsupported required check(s): ${unknownChecks.join(", ")}`);
+  for (const file of plan.files) {
+    if (file.startsWith("/") || /^[a-z]:/i.test(file) || file.includes("\\")) throw new Error(`Plan file must be site-relative: ${file}`);
+    within(root, file);
+  }
+  return withMutationLock(root, () => {
+    const receiptPath = join3(root, `agent/requests/${request.id}/engine-preparation.json`);
+    const payloadHash = digest({ request, plan });
+    if (existsSync3(receiptPath)) {
+      const existing = json(receiptPath);
+      if (existing.payloadHash !== payloadHash) throw new Error(`Request ID '${request.id}' is already used for different content`);
+      const { payloadHash: _payloadHash, ...prepared2 } = existing;
+      return prepared2;
+    }
+    const baselineRevision = sourceRevision(root);
+    if (baselineRevision.digest !== request.baseRevision) throw new Error(`Source revision conflict: expected ${request.baseRevision}, current ${baselineRevision.digest}`);
+    const prepared = prepareRefine({
+      root,
+      instruction: request.instruction,
+      requestId: request.id,
+      plan,
+      explicitPreferences: request.explicitPreferences,
+      origin: request.origin
+    });
+    const backupRoot = join3(root, `agent/requests/${request.id}/source-backup`);
+    const backup = { schemaVersion: 1, files: plan.files.map((path) => {
+      const source = within(root, path);
+      if (!existsSync3(source)) return { path, sha256: null };
+      const target = within(backupRoot, path);
+      mkdirSync(dirname2(target), { recursive: true });
+      cpSync(source, target);
+      return { path, sha256: createHash("sha256").update(readFileSync3(source)).digest("hex") };
+    }) };
+    save(join3(root, `agent/requests/${request.id}/source-backup.json`), backup);
+    const result = {
+      status: "prepared",
+      request,
+      plan,
+      baselineRevision,
+      preparedRevision: sourceRevision(root),
+      baselinePath: prepared.baselinePath,
+      impactedNodes: prepared.impactedNodes
+    };
+    save(receiptPath, { ...result, payloadHash });
+    return result;
+  });
+}
+function findElement(html, elementId) {
+  const tree = parseFragment3(html, { sourceCodeLocationInfo: true });
+  const matches = [];
+  const walk = (node) => {
+    if (elementMatchesIdentity(node.attrs, elementId)) matches.push(node);
+    for (const child of node.childNodes || []) walk(child);
+  };
+  walk(tree);
+  if (matches.length !== 1) throw new Error(`Element '${elementId}' must resolve exactly once`);
+  return matches[0];
+}
+function replaceElementText(html, elementId, text) {
+  const children = findElement(html, elementId).childNodes || [];
+  if (children.length !== 1 || children[0].nodeName !== "#text" || !children[0].sourceCodeLocation) {
+    throw new Error(`Element '${elementId}' contains custom markup; edit it with the agent`);
+  }
+  const loc = children[0].sourceCodeLocation;
+  const escaped = text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  return html.slice(0, loc.startOffset) + escaped + html.slice(loc.endOffset);
+}
+function replaceMedia(html, elementId, src) {
+  if (!/^\/media\/[a-zA-Z0-9/_.,-]+$/.test(src) || src.split("/").some((part) => part === "." || part === "..")) {
+    throw new Error("Media source must be a local /media/ asset");
+  }
+  const node = findElement(html, elementId);
+  if (node.nodeName !== "img" || !node.sourceCodeLocation?.startTag) throw new Error(`Element '${elementId}' is not an editable image`);
+  const { startOffset, endOffset } = node.sourceCodeLocation.startTag;
+  const tag = html.slice(startOffset, endOffset);
+  const match = /\bsrc\s*=\s*(["'])(.*?)\1/i.exec(tag);
+  if (!match) throw new Error(`Image '${elementId}' has no src attribute`);
+  const updated = tag.slice(0, match.index) + `src=${match[1]}${src}${match[1]}` + tag.slice(match.index + match[0].length);
+  return html.slice(0, startOffset) + updated + html.slice(endOffset);
+}
+function assertRegisteredMedia(root, src) {
+  const path = src.slice(1);
+  const inventoryPath = join3(root, "onboarding/media-inventory.json");
+  if (!existsSync3(inventoryPath)) throw new Error("Image replacement requires onboarding/media-inventory.json with asset provenance");
+  const inventory = json(inventoryPath);
+  const matches = (inventory.assets || []).filter((asset2) => asset2.path?.replaceAll("\\", "/").replace(/^\//, "") === path);
+  if (matches.length !== 1) throw new Error(`Media asset '${src}' must have one inventory identity`);
+  const asset = matches[0];
+  if (!asset.id || !["use", "retain"].includes(asset.disposition || "") || !asset.sources?.some((source) => source.trim())) {
+    throw new Error(`Media asset '${src}' lacks usable provenance or disposition`);
+  }
+  const file = within(root, path);
+  if (!existsSync3(file)) throw new Error(`Media asset '${src}' does not exist`);
+  const actual = createHash("sha256").update(readFileSync3(file)).digest("hex");
+  if (asset.sha256 !== actual) throw new Error(`Media asset '${src}' inventory hash does not match local bytes`);
+}
+function moveSection(html, sectionId, beforeSectionId) {
+  if (sectionId === beforeSectionId) throw new Error("Section cannot be moved before itself");
+  const tree = parseFragment3(html, { sourceCodeLocationInfo: true });
+  const pairs = [];
+  const walk = (node) => {
+    const children = node.childNodes || [];
+    children.forEach((child, index) => {
+      if (child.nodeName === "section" && child.attrs?.some((attr2) => attr2.name === "data-vitris-movable")) pairs.push({ children, index, node: child });
+      walk(child);
+    });
+  };
+  walk(tree);
+  const byId = (id) => pairs.filter((pair) => pair.node.attrs?.some((attr2) => attr2.name === "id" && attr2.value === id));
+  const source = byId(sectionId), target = byId(beforeSectionId);
+  if (source.length !== 1 || target.length !== 1 || source[0].children !== target[0].children) throw new Error("Sections must be unique movable siblings");
+  const a = source[0], b = target[0];
+  const from = a.node.sourceCodeLocation, to = b.node.sourceCodeLocation;
+  if (!from || !to) throw new Error("Section source mapping is unavailable");
+  if (a.index < b.index) {
+    throw new Error(`Section '${sectionId}' is already before '${beforeSectionId}'`);
+  }
+  const gap = html.slice(to.endOffset, from.startOffset);
+  if (gap.trim()) throw new Error("Intervening source is not whitespace");
+  return html.slice(0, to.startOffset) + html.slice(from.startOffset, from.endOffset) + gap + html.slice(to.startOffset, to.endOffset) + html.slice(from.endOffset);
+}
+function applyOperations(siteRoot, requestId, operations, manifestRevision) {
+  const root = resolve2(siteRoot);
+  assertRequestId(requestId);
+  if (!Array.isArray(operations) || operations.length !== 1) throw new Error("Exactly one source operation is supported per draft save");
+  const operation = operations[0];
+  if (operation.kind === "set_text" && (typeof operation.elementId !== "string" || !operation.elementId || typeof operation.text !== "string")) throw new Error("Invalid set_text operation");
+  if (operation.kind === "replace_media" && (typeof operation.elementId !== "string" || !operation.elementId || typeof operation.src !== "string")) throw new Error("Invalid replace_media operation");
+  if (operation.kind === "set_theme_token" && (typeof operation.token !== "string" || !operation.token || typeof operation.value !== "string")) throw new Error("Invalid set_theme_token operation");
+  if (operation.kind === "move_section" && (typeof operation.sectionId !== "string" || typeof operation.beforeSectionId !== "string")) throw new Error("Invalid move_section operation");
+  if (operation.kind !== "set_theme_token" && (!operation.file.endsWith(".html") || !operation.file.startsWith("pages/") && !operation.file.startsWith("components/"))) throw new Error("Operation must target a page or component HTML file");
+  return withMutationLock(root, () => {
+    const prepared = json(join3(root, `agent/requests/${requestId}/engine-preparation.json`));
+    if (!prepared.plan.files.includes(operation.file)) throw new Error(`File '${operation.file}' was not included in the change plan`);
+    const resultPath = join3(root, `agent/requests/${requestId}/engine-apply.json`);
+    const operationsHash = digest(operations);
+    if (existsSync3(resultPath)) {
+      const prior = json(resultPath);
+      if (prior.operationsHash !== operationsHash) throw new Error(`Request ID '${requestId}' was applied with different operations`);
+      if (sourceRevision(root).digest !== prior.afterRevision.digest) throw new Error("Applied draft has changed since the first save");
+      const { operationsHash: _operationsHash, ...applied } = prior;
+      return applied;
+    }
+    const beforeRevision = sourceRevision(root);
+    if (beforeRevision.digest !== prepared.preparedRevision.digest) throw new Error("Source revision changed after preparation; inspect and replan before saving");
+    if (manifestRevision && manifestRevision !== prepared.baselineRevision.digest) throw new Error("Stale editor manifest; rebuild and reselect the field");
+    const file = within(root, operation.file);
+    const source = readFileSync3(file, "utf8");
+    let updated;
+    if (operation.kind === "set_text") updated = replaceElementText(source, operation.elementId, operation.text);
+    else if (operation.kind === "replace_media") {
+      assertRegisteredMedia(root, operation.src);
+      updated = replaceMedia(source, operation.elementId, operation.src);
+    } else if (operation.kind === "move_section") updated = moveSection(source, operation.sectionId, operation.beforeSectionId);
+    else {
+      const theme = JSON.parse(source);
+      if (!Object.hasOwn(theme, operation.token) || typeof theme[operation.token] !== "string") throw new Error(`Theme token '${operation.token}' is not declared`);
+      theme[operation.token] = operation.value;
+      updated = `${JSON.stringify(theme, null, 2)}
+`;
+    }
+    if (updated === source) throw new Error("Operation did not change the source");
+    const temporary = `${file}.tmp.${process.pid}.${randomUUID()}`;
+    writeFileSync(temporary, updated);
+    recoverableReplace(temporary, file);
+    const afterRevision = sourceRevision(root);
+    const result = {
+      status: "draft",
+      requestId,
+      beforeRevision,
+      afterRevision,
+      changedFiles: changedSourceFiles(beforeRevision, afterRevision)
+    };
+    save(resultPath, { ...result, operationsHash });
+    return result;
+  });
+}
+async function buildSiteDraft(siteRoot) {
+  const root = resolve2(siteRoot);
+  const before = sourceRevision(root);
+  await buildVerified(root);
+  const after = sourceRevision(root);
+  if (before.digest !== after.digest) throw new Error("Source changed while building; rebuild against the new revision");
+  generateEditManifest(root);
+  return { sourceRevision: after, buildDigest: fingerprint(root, ["dist"]), output: join3(root, "dist") };
+}
+async function verifyChange(siteRoot, requestId) {
+  const root = resolve2(siteRoot);
+  assertRequestId(requestId);
+  const prepared = json(join3(root, `agent/requests/${requestId}/engine-preparation.json`));
+  const before = prepared.preparedRevision;
+  const current = sourceRevision(root);
+  const changedFiles = changedSourceFiles(before, current);
+  if (changedFiles.length === 0) throw new Error("No authored source changed after preparation");
+  const unplannedFiles = changedFiles.filter((file) => !prepared.plan.files.includes(file));
+  if (unplannedFiles.length) {
+    throw new Error(`Source impact exceeds the prepared plan: ${unplannedFiles.join(", ")}. Inspect the edits and prepare a new plan before verification`);
+  }
+  const impactFailures = copyImpactFailures(root, requestId, prepared.plan, changedFiles);
+  const checked = await verifyRefine({ root, requestId, accept: false });
+  const requiredFailures = prepared.plan.requiredChecks.filter((id) => checked.completedChecks?.[id] !== "pass").map((id) => `Required check ${id} did not pass (${checked.completedChecks?.[id] || "unevaluated"})`);
+  return withMutationLock(root, () => {
+    if (sourceRevision(root).digest !== current.digest || checked.verifiedSourceRevision !== current.digest) {
+      throw new Error("Source changed during verification; candidate was not accepted");
+    }
+    const buildDigest = checked.verifiedBuildDigest || "missing";
+    if (checked.verifiedBuildDigest && fingerprint(root, ["dist"]) !== checked.verifiedBuildDigest) {
+      throw new Error("Built artifact changed during verification; candidate was not accepted");
+    }
+    if (checked.ok && requiredFailures.length === 0 && impactFailures.length === 0) acceptVerifiedRefine(root, requestId);
+    const after = sourceRevision(root);
+    const technical = requiredFailures.length || impactFailures.length ? "fail" : checked.technical || "unevaluated";
+    const receipt = {
+      schemaVersion: 1,
+      subjectRevision: after.digest,
+      buildDigest,
+      checks: [
+        { id: "refinement-technical", version: "1", outcome: technical, evidence: [`agent/requests/${requestId}/request.json`] },
+        { id: "refinement-fulfillment", version: "1", outcome: checked.fulfillment || "unevaluated", evidence: [`agent/requests/${requestId}/request.json`] },
+        { id: "source-impact", version: "1", outcome: impactFailures.length ? "fail" : "pass", evidence: [`agent/requests/${requestId}/source-backup.json`] },
+        ...prepared.plan.requiredChecks.map((id) => ({
+          id,
+          version: "1",
+          outcome: checked.completedChecks?.[id] || "unevaluated",
+          evidence: [id === "build" ? "dist" : `agent/screenshots/refine/${requestId}`]
+        }))
+      ],
+      reviewer: "machine",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const result = {
+      schemaVersion: 1,
+      requestId,
+      beforeRevision: before.digest,
+      afterRevision: after.digest,
+      changedFiles,
+      changedTargets: prepared.plan.targets,
+      technical,
+      fulfillment: checked.fulfillment || "unevaluated",
+      design: checked.design || "unevaluated",
+      unresolved: [...checked.failures, ...requiredFailures, ...impactFailures],
+      previewDigest: buildDigest,
+      receipt
+    };
+    save(join3(root, `agent/requests/${requestId}/engine-result.json`), result);
+    return result;
+  });
+}
+function discardChange(siteRoot, requestId, candidateRevision) {
+  const root = resolve2(siteRoot);
+  assertRequestId(requestId);
+  return withMutationLock(root, () => {
+    const requestRoot = join3(root, `agent/requests/${requestId}`);
+    const prepared = json(join3(requestRoot, "engine-preparation.json"));
+    const current = sourceRevision(root);
+    if (current.digest !== candidateRevision) throw new Error("Candidate revision changed; inspect before discard");
+    const changed = changedSourceFiles(prepared.preparedRevision, current);
+    if (!changed.length) return { status: "already_discarded", revision: current, restoredFiles: [] };
+    const unplanned = changed.filter((path) => !prepared.plan.files.includes(path));
+    if (unplanned.length) throw new Error(`Cannot discard unplanned source changes: ${unplanned.join(", ")}`);
+    const resultPath = join3(requestRoot, "engine-result.json");
+    if (existsSync3(resultPath)) {
+      const result = json(resultPath);
+      if (result.technical === "pass" && result.fulfillment === "pass") throw new Error("Verified change is accepted; use a new reversal request");
+    }
+    const backup = json(join3(requestRoot, "source-backup.json"));
+    for (const entry of backup.files) {
+      if (entry.sha256 === null) continue;
+      const saved = within(root, `agent/requests/${requestId}/source-backup/${entry.path}`);
+      if (!existsSync3(saved) || createHash("sha256").update(readFileSync3(saved)).digest("hex") !== entry.sha256) {
+        throw new Error(`Source backup for ${entry.path} is missing or changed`);
+      }
+    }
+    for (const entry of backup.files.filter((item) => changed.includes(item.path))) {
+      const dest = within(root, entry.path);
+      if (entry.sha256 === null) {
+        if (existsSync3(dest)) unlinkSync(dest);
+        continue;
+      }
+      mkdirSync(dirname2(dest), { recursive: true });
+      const temporary = `${dest}.discard-${process.pid}-${randomUUID()}`;
+      cpSync(within(root, `agent/requests/${requestId}/source-backup/${entry.path}`), temporary);
+      recoverableReplace(temporary, dest);
+    }
+    const restored = sourceRevision(root);
+    if (restored.digest !== prepared.preparedRevision.digest) throw new Error("Restored source does not match the prepared revision; inspect the candidate");
+    save(join3(requestRoot, "engine-discard.json"), {
+      schemaVersion: 1,
+      requestId,
+      candidateRevision,
+      restoredRevision: restored.digest,
+      restoredFiles: changed,
+      discardedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { status: "discarded", revision: restored, restoredFiles: changed };
+  });
+}
+
+export {
+  generateEditManifest,
+  publicEditManifest,
+  inspectSite,
+  prepareChange,
+  applyOperations,
+  buildSiteDraft,
+  verifyChange,
+  discardChange
+};