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

package/bin/chunks/chunk-T7DGRVTP.js

@@ -0,0 +1,458 @@
+import {
+  digest
+} from "./chunk-AUO5I56E.js";
+import {
+  fingerprint,
+  sourceHash,
+  within
+} from "./chunk-T6PE4KN4.js";
+
+// src/agent/playwright-runtime.ts
+async function loadPlaywrightChromium() {
+  let imported;
+  try {
+    imported = await import("playwright");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const missing = error.code === "ERR_MODULE_NOT_FOUND" || /Cannot find package ['"]playwright['"]/.test(message);
+    if (missing) {
+      throw new Error("The playwright npm package is not installed. @tryvitris/website-harness depends on it for browser capture. Reinstall the package so its dependencies are installed. Browser binaries are separate: after the package is present, run `npx playwright install chromium`.");
+    }
+    throw error;
+  }
+  const chromium = imported.chromium || imported.default?.chromium;
+  if (!chromium?.launch) {
+    throw new Error("The installed playwright package did not export chromium. Reinstall playwright, then run `npx playwright install chromium`.");
+  }
+  return chromium;
+}
+function explainBrowserLaunchFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/executable doesn't exist|browserType\.launch|npx playwright install|Failed to launch/i.test(message)) {
+    return `Playwright is installed, but the Chromium browser binary is not provisioned. Run: npx playwright install chromium
+${message}`;
+  }
+  return message;
+}
+
+// src/agent/template-motion.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var TEMPLATE_MOTION_PATH = "agent/decisions/template-motion.json";
+var templateMotionHash = (plan) => digest(plan);
+function validateTemplateMotionPlan(plan) {
+  const failures = [];
+  if (plan?.version !== 1 || !plan.selectionHash || !/^https:\/\//.test(plan.referenceUrl || "") || !Array.isArray(plan.moments) || !plan.moments.length) return ["Template motion needs a versioned plan, selection and pinned HTTPS reference"];
+  if (new Set(plan.moments.map((m) => m.id)).size !== plan.moments.length) failures.push("Duplicate template motion moment IDs");
+  if (!plan.moments.some((m) => m.kind === "load")) failures.push("Fresh-session load comparison required: inspect the opening from navigation start");
+  for (const m of plan.moments) {
+    if (!/^[\w-]+$/.test(m.id) || !["load", "marquee", "pointer-follow", "magnetic", "scroll", "route", "drawer", "sequence"].includes(m.kind) || !m.intent?.trim() || !Number.isInteger(m.width) || m.width < 320 || m.width > 2560 || [m.reference, m.implementation].some((s) => !s?.path?.startsWith("/") || !s.target?.trim() || !s.observe?.trim())) failures.push("Invalid located motion moment: " + m.id);
+  }
+  for (const m of plan.moments) for (const side of [m.reference, m.implementation]) if (side?.requiredPhases !== void 0 && (!Array.isArray(side.requiredPhases) || side.requiredPhases.some((p) => typeof p !== "string" || !p.trim()))) failures.push("Invalid required transition phases: " + m.id);
+  return failures;
+}
+function templateMotionReviewFailures(root, selectionHash, node) {
+  const path = join(root, TEMPLATE_MOTION_PATH);
+  if (!existsSync(path)) return [];
+  const plan = JSON.parse(readFileSync(path, "utf8"));
+  const errors = validateTemplateMotionPlan(plan);
+  if (plan.selectionHash !== selectionHash) errors.push("Template motion plan belongs to a different selection");
+  if (!["representative-review", "visual-review"].includes(node)) return errors;
+  const reportPath = join(root, "agent/reviews/" + (node === "representative-review" ? "representative-browser" : "browser") + ".json");
+  const evidence = existsSync(reportPath) ? JSON.parse(readFileSync(reportPath, "utf8")).templateMotion : void 0;
+  if (!evidence || evidence.version !== 1 || evidence.planHash !== templateMotionHash(plan) || evidence.selectionHash !== selectionHash || evidence.distHash !== fingerprint(root, ["dist"])) return [...errors, "Current recorded template motion comparison missing or stale"];
+  const files = new Map((evidence.files || []).map((f) => [f.path, f.hash]));
+  for (const m of plan.moments) for (const side of ["reference", "implementation"]) {
+    const c = evidence.captures?.find((c2) => c2.momentId === m.id && c2.side === side && c2.width === m.width);
+    if (!c || !Array.isArray(c.failures) || c.failures.length || !Array.isArray(c.frames) || c.frames.length < 3 || !Array.isArray(c.samples) || c.samples.length < 3 || !c.video) {
+      errors.push("Incomplete temporal comparison: " + m.id + " / " + side);
+      continue;
+    }
+    for (const phase of Array.isArray(m[side].requiredPhases) ? m[side].requiredPhases : []) if (!Array.isArray(c.phaseStates) || !c.phaseStates.some((s) => s.phase === phase)) errors.push("Missing recorded transition phase: " + m.id + " / " + side + " / " + phase);
+    for (const path2 of [...c.frames, c.video]) {
+      try {
+        if (!files.get(path2) || !existsSync(within(root, path2)) || files.get(path2) !== fingerprint(root, [path2])) errors.push("Changed or missing template motion capture: " + path2);
+      } catch {
+        errors.push("Unsafe template motion capture: " + path2);
+      }
+    }
+    if (new Set(c.samples.map((s) => s.state)).size < 2 && !m.departure?.trim()) errors.push("No observed temporal change or explained departure: " + m.id + " / " + side);
+  }
+  const reviewPath = join(root, "agent/reviews/" + node + ".json");
+  const fidelity = existsSync(reviewPath) ? JSON.parse(readFileSync(reviewPath, "utf8")).templateMotion : void 0;
+  if (!fidelity || fidelity.planHash !== templateMotionHash(plan) || fidelity.distHash !== evidence.distHash) errors.push("Temporal fidelity review missing or stale");
+  else for (const m of plan.moments) {
+    const comparison = fidelity.moments?.find((r) => r.id === m.id);
+    if (!comparison || comparison.verdict !== "pass" || ["timing", "easing", "continuity", "inputAlternatives"].some((k) => !comparison[k]?.trim())) errors.push("Located temporal assessment missing: " + m.id);
+  }
+  return errors;
+}
+
+// src/agent/motion-composition.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { parseFragment } from "parse5";
+function motionCompositionPolicy(root, routes) {
+  const site = existsSync2(join2(root, "site.json")) ? JSON.parse(readFileSync2(join2(root, "site.json"), "utf8")) : {};
+  const policy = site.motionComposition;
+  const requestPath = join2(root, "agent/change-request.json"), request = existsSync2(requestPath) ? JSON.parse(readFileSync2(requestPath, "utf8")) : {};
+  const reauthored = [request.scope, ...request.scopes || []].some((s) => ["pages", "direction"].includes(s)) ? (request.affectedPages || []).filter((p) => routes.includes(p)) : [];
+  return { operatorOff: site.scrollMotion?.policy === "off", requiredRoutes: [.../* @__PURE__ */ new Set([...policy?.version === 2 ? policy.routes === "all-authored" ? routes : Array.isArray(policy.routes) ? policy.routes : [] : [], ...reauthored])] };
+}
+function validateRouteComposition(plan, routes, options = {}) {
+  const errors = [];
+  if (options.requiredRoutes?.length && plan?.version !== 2) return ["Required motionPlan v2 missing: compose every authored route, including expansion; a legacy scene list is insufficient"];
+  if (plan?.version !== 2) return errors;
+  if (!Array.isArray(plan.routes)) return ["motionPlan v2 requires route compositions"];
+  const required = options.requiredRoutes?.length ? options.requiredRoutes : routes || plan.routes.map((r) => r.route);
+  for (const route of required) if (!plan.routes.some((r) => r.route === route)) errors.push(`Missing motion composition for authored route: ${route}`);
+  if (new Set(plan.routes.map((r) => r.route)).size !== plan.routes.length) errors.push("Duplicate route motion composition");
+  for (const r of plan.routes) {
+    if (!r.route?.startsWith("/") || routes && !routes.includes(r.route) || ["task", "character", "normal", "mobile", "reduced", "ending"].some((k) => !r[k]?.trim()) || !Array.isArray(r.available) || !r.available.length || !Array.isArray(r.beats) || !r.beats.length) {
+      errors.push(`Incomplete route composition: ${r.route}`);
+      continue;
+    }
+    const routeScenes = plan.scenes.filter((s) => s.route === r.route), expected = options.sections?.[r.route];
+    if (expected && expected.join("|") !== r.beats.map((b) => b.sectionId).join("|")) errors.push(`Content beats missing/out of document order: ${r.route}; expected ${expected.join(", ")}`);
+    if (new Set(r.beats.map((b) => b.sectionId)).size !== r.beats.length) errors.push(`Duplicate content beat: ${r.route}`);
+    for (const [i, b] of r.beats.entries()) {
+      const role = r.beats.length === 1 ? "whole" : i === 0 ? "opening" : i === r.beats.length - 1 ? "closing" : "development";
+      if (!/^[A-Za-z][\w-]*$/.test(b.sectionId || "") || !b.change?.trim() || !b.transition?.trim() || !Array.isArray(b.scenes) || b.role !== role) errors.push(`Incomplete/incorrectly ordered motion beat: ${r.route}#${b.sectionId}`);
+      for (const id of b.scenes || []) if (!routeScenes.some((s) => s.targetId === id)) errors.push(`Unbound beat scene: ${r.route}#${b.sectionId}/${id}`);
+      if (!options.operatorOff && !b.scenes?.length) {
+        const a = b.connects?.map((id) => r.beats.findIndex((x) => x.scenes?.includes(id)));
+        if (!a || a.length !== 2 || (a[0] ?? -1) < 0 || (a[0] ?? -1) >= i || (a[1] ?? -1) <= i) errors.push(`Quiet interval needs located active moments on both sides: ${r.route}#${b.sectionId}`);
+      }
+    }
+    for (const s of routeScenes) if (!r.beats.some((b) => b.scenes?.includes(s.targetId))) errors.push(`Scene omitted from journey: ${r.route}#${s.targetId}`);
+    if (!options.operatorOff) {
+      if (!r.beats[0]?.scenes?.length || !r.beats.at(-1)?.scenes?.length) errors.push(`Opening/closing not composed: ${r.route}; one isolated region cannot stand for the whole route`);
+      if (!routeScenes.some((s) => s.mobile === "same")) errors.push(`Mobile route has no active treatment: ${r.route}`);
+    }
+  }
+  return errors;
+}
+function compositionBindingFailures(plan, route, html) {
+  if (plan?.version !== 2) return [];
+  const r = plan.routes?.find((r2) => r2.route === route);
+  if (!r) return [];
+  const elements = [], walk = (n) => {
+    if (n.attrs) elements.push(n);
+    for (const c of n.childNodes || []) walk(c);
+  };
+  walk(parseFragment(html));
+  const get = (n, k) => n?.attrs?.find((a) => a.name === k)?.value, byId = (id) => elements.filter((n) => get(n, "id") === id), contains = (root, n) => root === n || (root?.childNodes || []).some((c) => contains(c, n));
+  const errors = [];
+  let last = -1;
+  for (const beat of r.beats) {
+    const nodes = byId(beat.sectionId), section = nodes[0], position = elements.indexOf(section);
+    if (nodes.length !== 1 || position <= last) errors.push(`Missing/out-of-order page beat: ${route}#${beat.sectionId}`);
+    last = position;
+    for (const id of beat.scenes) if (!byId(id)[0] || !contains(section, byId(id)[0])) errors.push(`Scene lies outside planned content beat: ${route}#${beat.sectionId}/${id}`);
+  }
+  for (const id of r.available) {
+    const nodes = byId(id);
+    if (nodes.length !== 1) errors.push(`Continuously available target missing: ${route}#${id}`);
+    else if (elements.some((n) => ["text", "entrance", "stagger", "sequence", "count"].includes(get(n, "data-motion")) && contains(n, nodes[0]))) errors.push(`Essential reading/action inside active target: ${route}#${id}`);
+  }
+  return errors;
+}
+function concentrationFailures(route, sections, scenes, viewport) {
+  const active = scenes.filter((s) => s.active), regions = new Set(active.map((s) => s.sectionId).filter(Boolean));
+  if (sections.length > 1 && regions.size === 1) {
+    const region = sections.find((s) => regions.has(s.id));
+    if (region && sections.some((s) => s.id !== region.id && (s.bottom <= region.top || s.top >= region.bottom) && s.bottom - s.top >= viewport * 0.5)) return [`Concentrated motion: ${route} all active scenes lie in #${region.id} while other substantial content is uncomposed; repair the opening/development/closing relationships, not an effect quota`];
+  }
+  return [];
+}
+
+// src/agent/browser-motion-journey.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3, relative } from "node:path";
+var JOURNEY_SCENARIO = { version: 6, fontSettlementMs: 5e3, arrivalSettlementMs: 5e3, openingObservationMs: 6e3, openingMs: 600, stepPx: 180, readingMs: 600, firstSampleMs: 120, settleMs: 1600, maxHeight: 6e4, modes: ["normal", "reduce", "static"], traversal: "early opening render-state sampling, real arrival settlement, then continuous forward native wheel through the final scroll pixel, overlapping viewport checkpoints including quiet intervals and closing; no target jumps" };
+var JOURNEY_SCENARIO_HASH = createHash("sha256").update(JSON.stringify(JOURNEY_SCENARIO)).digest("hex");
+async function captureMotionJourney(browser, root, url, route, width, mode, directory, plan, operatorOff = false) {
+  const folder = join3(root, directory);
+  mkdirSync(folder, { recursive: true });
+  const context = await browser.newContext({ viewport: { width, height: 900 }, reducedMotion: mode === "reduce" ? "reduce" : "no-preference", javaScriptEnabled: mode !== "static", ...mode === "normal" ? { recordVideo: { dir: folder, size: { width, height: 900 } } } : {} });
+  const page = await context.newPage(), composition = plan.routes?.find((r) => r.route === route), declared = plan.scenes.filter((s) => s.route === route), html = readFileSync3(join3(root, `dist${route === "/" ? "" : route}/index.html`), "utf8"), asset = html.match(/src=["'](\/motion-[^"']+\.js)["']/)?.[1];
+  const result = { path: route, width, mode, sourceHash: sourceHash(root), outputHash: fingerprint(root, ["dist"]), planHash: fingerprint(root, ["onboarding/storyboard.json"]), scenarioHash: JOURNEY_SCENARIO_HASH, engineAssetHash: asset ? fingerprint(root, [`dist${asset}`]) : "", sections: [], scenes: [], checkpoints: [], failures: [] };
+  const started = Date.now();
+  try {
+    page.on("pageerror", (e) => result.failures.push(e.message));
+    await page.route("**/api/**", (r) => r.fulfill({ status: 204, body: "" }));
+    if (mode === "normal") await page.addInitScript(({ ids, started: started2, limit }) => {
+      const buffer = window.__vitrisJourneyOpening = { stopped: false, checkpoints: [] }, previous2 = /* @__PURE__ */ new Map();
+      const tick = () => {
+        if (buffer.stopped || Date.now() - started2 > limit) return;
+        const states = ids.flatMap((id) => {
+          const e = document.getElementById(id), state = window.VitrisMotion?.inspect(id);
+          if (!e || state?.static !== false) return [];
+          const nodes = [e, ...e.querySelectorAll("[data-motion-word],[data-motion-child],[data-motion-path],[data-motion-visual]")];
+          return [{ id, signature: JSON.stringify(nodes.map((n) => {
+            const s = getComputedStyle(n);
+            return [s.opacity, s.transform, s.clipPath, s.strokeDashoffset, n.hasAttribute("data-motion-visual") ? n.textContent : ""];
+          })), phase: state.phase || null, static: false }];
+        });
+        const changed = states.some((s) => previous2.get(s.id) !== s.signature);
+        states.forEach((s) => previous2.set(s.id, s.signature));
+        if (changed && buffer.checkpoints.length < 128) buffer.checkpoints.push({ y: scrollY, timeMs: Date.now() - started2, states });
+        window.requestAnimationFrame(tick);
+      };
+      window.requestAnimationFrame(tick);
+    }, { ids: declared.map((s) => s.targetId), started, limit: JOURNEY_SCENARIO.openingObservationMs });
+    await page.goto(url, { waitUntil: "domcontentloaded" });
+    const fontsSettled = await page.evaluate(async (ms) => await Promise.race([document.fonts.ready.then(() => true), new Promise((resolve) => setTimeout(() => resolve(false), ms))]), JOURNEY_SCENARIO.fontSettlementMs);
+    if (!fontsSettled) throw Error("Fonts did not settle before full-journey geometry capture");
+    if (mode !== "static") await page.waitForFunction(() => !document.documentElement.dataset.experienceArrival, {}, { timeout: JOURNEY_SCENARIO.arrivalSettlementMs });
+    const reject = page.locator("[data-cookie-reject]");
+    if (mode !== "static" && await reject.isVisible()) await reject.click();
+    await page.waitForTimeout(50);
+    const geometry = await page.evaluate(({ ids, beatIds }) => {
+      const sections = [.../* @__PURE__ */ new Set([...beatIds.map((id) => document.getElementById(id)), ...document.querySelectorAll("main section[id],main article[id]")])].filter(Boolean).map((e) => ({ id: e.id, top: e.getBoundingClientRect().top + scrollY, bottom: e.getBoundingClientRect().bottom + scrollY })).sort((a, b) => a.top - b.top);
+      const scenes = ids.map((id) => {
+        const e = document.getElementById(id), s = e?.closest("section[id],article[id],[data-section-id]");
+        return { id, sectionId: s?.id || beatIds.find((id2) => document.getElementById(id2)?.contains(e)) || null, top: e ? e.getBoundingClientRect().top + scrollY : 0, bottom: e ? e.getBoundingClientRect().bottom + scrollY : 0, active: false };
+      });
+      return { sections, scenes, height: document.documentElement.scrollHeight };
+    }, { ids: declared.map((s) => s.targetId), beatIds: composition?.beats.map((b) => b.sectionId) || [] });
+    result.sections = geometry.sections;
+    result.scenes = geometry.scenes;
+    if (geometry.height > JOURNEY_SCENARIO.maxHeight) throw Error("Route exceeds bounded full-journey capture height; no partial journey may pass");
+    const sample = async (index2, final = false) => {
+      const snapshot = await page.evaluate(({ ids, available, readable }) => ({ y: scrollY, states: ids.map((id) => {
+        const e = document.getElementById(id), state = window.VitrisMotion?.inspect(id);
+        const nodes = e ? [e, ...e.querySelectorAll("[data-motion-word],[data-motion-child],[data-motion-path],[data-motion-visual]")] : [];
+        return { id, signature: JSON.stringify(nodes.map((n) => {
+          const s = getComputedStyle(n);
+          return [s.opacity, s.transform, s.clipPath, s.strokeDashoffset, n.hasAttribute("data-motion-visual") ? n.textContent : ""];
+        })), phase: state?.phase || null, static: state?.static ?? null, stickyTop: e?.getAttribute("data-motion") === "story" ? [e, ...e.querySelectorAll("*")].find((n) => getComputedStyle(n).position === "sticky")?.getBoundingClientRect().top ?? null : null };
+      }), unavailable: available.filter((id) => {
+        const e = document.getElementById(id);
+        return !e || getComputedStyle(e).visibility === "hidden" || Number(getComputedStyle(e).opacity) < 0.99 || !e.getClientRects().length;
+      }), unreadable: readable ? ids.filter((id) => {
+        const e = document.getElementById(id);
+        return !e || [e, ...e.querySelectorAll("[data-motion-word],[data-motion-child]")].some((n) => Number(getComputedStyle(n).opacity) < 0.99 || getComputedStyle(n).visibility === "hidden");
+      }) : [] }), { ids: declared.map((s) => s.targetId), available: composition?.available || [], readable: mode !== "normal" || final });
+      for (const id of snapshot.unavailable) result.failures.push(`Essential content/action unavailable in journey: ${route}#${id}`);
+      for (const id of snapshot.unreadable) result.failures.push(`Final/reduced/static content unreadable: ${route}#${id}`);
+      const checkpoint = { y: snapshot.y, timeMs: Date.now() - started, states: snapshot.states };
+      if (index2 % 3 === 0 || final) {
+        const path = `${directory}/${route.replace(/[^a-z0-9]/gi, "-")}-${width}-${mode}-${index2}.png`;
+        await page.screenshot({ path: join3(root, path), animations: "allow" });
+        checkpoint.screenshot = path;
+        checkpoint.screenshotHash = fingerprint(root, [path]);
+      }
+      result.checkpoints.push(checkpoint);
+    };
+    if (mode === "normal") result.checkpoints.push(...await page.evaluate(() => {
+      const buffer = window.__vitrisJourneyOpening;
+      if (!buffer) return [];
+      buffer.stopped = true;
+      return buffer.checkpoints;
+    }));
+    let index = 0;
+    await sample(index++);
+    await page.waitForTimeout(JOURNEY_SCENARIO.openingMs);
+    let previous = -1;
+    while (true) {
+      const position = await page.evaluate(() => ({ y: scrollY, max: document.documentElement.scrollHeight - innerHeight }));
+      if (position.y >= position.max - 0.5) break;
+      if (position.y === previous && index > 2) throw Error("Native traversal did not advance");
+      previous = position.y;
+      await page.mouse.wheel(0, Math.min(JOURNEY_SCENARIO.stepPx, position.max - position.y));
+      await page.waitForTimeout(JOURNEY_SCENARIO.firstSampleMs);
+      await sample(index++);
+      await page.waitForTimeout(JOURNEY_SCENARIO.readingMs - JOURNEY_SCENARIO.firstSampleMs);
+    }
+    await page.waitForTimeout(JOURNEY_SCENARIO.settleMs);
+    await sample(index, true);
+    for (const scene of result.scenes) {
+      const states = result.checkpoints.flatMap((c) => c.states.filter((s) => s.id === scene.id)), intent = declared.find((s) => s.targetId === scene.id);
+      scene.active = scenePlayed(result.checkpoints, scene.id, intent.effect);
+      if (mode === "normal" && !operatorOff && !(width < 600 && intent.mobile === "static") && !scene.active) result.failures.push(`Planned scene inert in full journey: ${route}#${scene.id}; inspect initial-visible/nested/large-target safeguards and choose a supporting target`);
+    }
+    if (mode === "normal" && !operatorOff) result.failures.push(...concentrationFailures(route, result.sections, result.scenes, 900));
+  } catch (error) {
+    result.failures.push(String(error));
+  } finally {
+    const video = page.video();
+    await context.close();
+    if (video) {
+      result.video = relative(root, await video.path()).replaceAll("\\", "/");
+      result.videoHash = fingerprint(root, [result.video]);
+    }
+  }
+  result.failures = [...new Set(result.failures)];
+  return result;
+}
+function scenePlayed(checkpoints, id, effect) {
+  const states = checkpoints.flatMap((c) => c.states.filter((s) => s.id === id));
+  if (effect !== "story") return new Set(states.map((s) => s.signature)).size > 1 && states.some((s) => s.static === false);
+  return checkpoints.some((c, i) => {
+    const previous = checkpoints[i - 1], a = previous?.states.find((s) => s.id === id), b = c.states.find((s) => s.id === id);
+    return previous && c.y > previous.y + 20 && typeof a?.stickyTop === "number" && typeof b?.stickyTop === "number" && Math.abs(a.stickyTop - b.stickyTop) < 2 && b.stickyTop >= 0 && b.stickyTop < 900;
+  });
+}
+function journeyEvidenceFailures(root, evidence, plan) {
+  const errors = [...evidence.failures];
+  const html = readFileSync3(join3(root, `dist${evidence.path === "/" ? "" : evidence.path}/index.html`), "utf8"), asset = html.match(/src=["'](\/motion-[^"']+\.js)["']/)?.[1];
+  if (evidence.sourceHash !== sourceHash(root) || evidence.outputHash !== fingerprint(root, ["dist"]) || evidence.planHash !== fingerprint(root, ["onboarding/storyboard.json"]) || evidence.scenarioHash !== JOURNEY_SCENARIO_HASH || evidence.engineAssetHash !== (asset ? fingerprint(root, [`dist${asset}`]) : "")) errors.push(`Route journey source/output/plan/scenario bytes stale: ${evidence.path}`);
+  if (!evidence.checkpoints.length || evidence.checkpoints[0].y > 2 || evidence.checkpoints.some((c, i) => i > 0 && (c.y < evidence.checkpoints[i - 1].y || c.y - evidence.checkpoints[i - 1].y > 900))) errors.push(`Route journey skipped content: ${evidence.path}`);
+  if ((evidence.checkpoints.at(-1)?.y || 0) + 900 < Math.max(0, ...evidence.sections.map((s) => s.bottom)) - 2) errors.push(`Route journey did not reach closing content: ${evidence.path}`);
+  for (const c of evidence.checkpoints) if (c.screenshot) {
+    try {
+      const bytes = readFileSync3(join3(root, c.screenshot));
+      if (!c.screenshotHash || fingerprint(root, [c.screenshot]) !== c.screenshotHash || ![137, 80, 78, 71, 13, 10, 26, 10].every((v, i) => bytes[i] === v)) errors.push(`Journey checkpoint corrupt/changed: ${c.screenshot}`);
+    } catch {
+      errors.push(`Journey checkpoint missing: ${c.screenshot}`);
+    }
+  }
+  if (evidence.mode === "normal" && (!evidence.video || !existsSync3(join3(root, evidence.video)) || fingerprint(root, [evidence.video]) !== evidence.videoHash)) errors.push(`Normal full-route recording missing/changed: ${evidence.path}`);
+  for (const s of plan.scenes.filter((s2) => s2.route === evidence.path)) if (!evidence.scenes.some((e) => e.id === s.targetId)) errors.push(`Scene omitted from full journey: ${evidence.path}#${s.targetId}`);
+  const off = motionCompositionPolicy(root, [evidence.path]).operatorOff;
+  for (const scene of plan.scenes.filter((s) => s.route === evidence.path)) {
+    const states = evidence.checkpoints.flatMap((c) => c.states.filter((s) => s.id === scene.targetId));
+    const played = scenePlayed(evidence.checkpoints, scene.targetId, scene.effect);
+    if (evidence.mode === "normal" && !off && !(evidence.width < 600 && scene.mobile === "static") && !played) errors.push(`Planned scene has no bound playback evidence: ${evidence.path}#${scene.targetId}`);
+  }
+  if (evidence.mode === "normal" && !off) errors.push(...concentrationFailures(evidence.path, evidence.sections, evidence.scenes, 900));
+  return [...new Set(errors)];
+}
+var MOTION_CRITIQUE_CRITERIA = ["whole-journey", "distribution-connections", "business-rhythm", "competition-stillness", "route-differences", "immediate-use"];
+function motionCritiqueFailures(root, review, routes, report) {
+  const errors = [];
+  for (const route of routes) {
+    const row = review.motionJourneys?.find((r) => r.route === route);
+    if (!row) {
+      errors.push(`Located whole-route motion critique missing: ${route}`);
+      continue;
+    }
+    for (const criterion of MOTION_CRITIQUE_CRITERIA) {
+      const check = row.checks?.find((c) => c.criterion === criterion);
+      if (!check || check.verdict !== "pass" || typeof check.evidence !== "string" || check.evidence.trim().length < 24 || !Array.isArray(check.checkpoints) || !check.checkpoints.length) {
+        errors.push(`Motion critique needs located judgment: ${route}/${criterion}`);
+        continue;
+      }
+      for (const path of check.checkpoints) {
+        const checkpoint = report.routeJourneys?.filter((j) => j.path === route).flatMap((j) => j.checkpoints).find((c) => c.screenshot === path);
+        if (!checkpoint || !existsSync3(join3(root, path)) || fingerprint(root, [path]) !== checkpoint.screenshotHash) errors.push(`Motion critique checkpoint stale/missing: ${route}/${path}`);
+      }
+    }
+  }
+  return errors;
+}
+
+// src/agent/browser-motion.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+var MOTION_SCENARIO = { version: 2, states: ["before", "during", "after"], triggerViewport: 0.78, duringMs: 120, settleMs: 1550, progress: [0, 0.5, 1], modes: ["normal", "reduce"], scrolling: "ordinary document flow, target checkpoints, forward and reverse", expressive: "canonical text, visual counter, authored phrase opacity, SVG stroke" };
+var MOTION_SCENARIO_HASH = createHash2("sha256").update(JSON.stringify(MOTION_SCENARIO)).digest("hex");
+async function observeMotion(page, root, route, width, mode, directory) {
+  const scripts = page.locator('script[src*="/motion-"]');
+  const asset = await scripts.count() ? await scripts.first().getAttribute("src") : null;
+  const evidence = { path: route, width, motion: mode, scenarioHash: MOTION_SCENARIO_HASH, engineAssetHash: asset ? fingerprint(root, [`dist/${asset.replace(/^\//, "")}`]) : "", targets: [], failures: [] };
+  if (!asset) return evidence;
+  await page.waitForTimeout(50);
+  const targets = await page.locator("[data-motion-target],[data-reveal]").evaluateAll((es) => es.map((e, i) => ({ id: e.id || `legacy-${i}`, effect: e.getAttribute("data-motion") || (e.hasAttribute("data-count-to") ? "count" : e.hasAttribute("data-reveal-stagger") ? "stagger" : "entrance"), index: i })));
+  for (const [index, declared] of targets.entries()) {
+    if (declared.id.startsWith("legacy-")) continue;
+    if (await page.locator(`[id="${declared.id}"]`).count() !== 1) {
+      evidence.failures.push(`Motion target not unique: ${declared.id}`);
+      continue;
+    }
+    const target = page.locator(`[id="${declared.id}"]`);
+    await page.evaluate(() => {
+      scrollTo(0, 0);
+      window.VitrisMotion?.init();
+    });
+    await page.waitForTimeout(50);
+    const samples = [];
+    const capture = async (state) => {
+      const value = await target.evaluate((e) => ({ opacity: Math.min(...[e, ...e.querySelectorAll("[data-motion-child],[data-reveal-child],[data-motion-word]")].map((n) => Number(getComputedStyle(n).opacity))), transform: getComputedStyle(e).transform, progress: window.VitrisMotion?.inspect(e.id)?.progress ?? null, canonical: e.querySelector("[data-motion-visual]") ? e.firstElementChild?.textContent || "" : e.textContent || "", visual: e.querySelector("[data-motion-visual]")?.textContent ?? null, stroke: e.querySelector("[data-motion-path]") ? getComputedStyle(e.querySelector("[data-motion-path]")).strokeDashoffset : "" }));
+      const path = `${directory}/motion-${route.replace(/[^a-z0-9]/gi, "-")}-${width}-${mode}-${index}-${state}.png`;
+      await page.screenshot({ path: join4(root, path), animations: "allow" });
+      samples.push({ state, ...value, screenshot: path, screenshotHash: fingerprint(root, [path]) });
+    };
+    await capture("before");
+    const top = await target.evaluate((e) => e.getBoundingClientRect().top + scrollY);
+    await page.evaluate((y) => scrollTo(0, Math.max(0, y - innerHeight * 0.78)), top);
+    await page.waitForTimeout(MOTION_SCENARIO.duringMs);
+    await capture("during");
+    await page.waitForTimeout(MOTION_SCENARIO.settleMs);
+    await capture("after");
+    if (["entrance", "stagger", "text", "sequence"].includes(declared.effect)) {
+      const unreadable = await target.evaluate((e) => [e, ...e.querySelectorAll("[data-motion-child],[data-reveal-child],[data-motion-word]")].some((n) => Number(getComputedStyle(n).opacity) < 0.99 || getComputedStyle(n).visibility === "hidden"));
+      if (unreadable) evidence.failures.push(`Motion content not readable after settling: ${declared.id}`);
+    }
+    if (mode === "reduce" && samples.some((s) => s.opacity < 0.99)) evidence.failures.push(`Reduced motion hid content: ${declared.id}`);
+    const runtimeState = await target.evaluate((e) => window.VitrisMotion?.inspect(e.id));
+    if (!runtimeState) evidence.failures.push(`Motion runtime did not initialize: ${declared.id}`);
+    if (mode === "normal" && !runtimeState?.static && ["entrance", "stagger", "text", "sequence"].includes(declared.effect) && samples.every((s) => s.opacity >= 0.99)) evidence.failures.push(`Declared entrance did not animate in the temporal scenario: ${declared.id}`);
+    if (declared.effect === "count") {
+      if (samples.some((s) => s.canonical !== samples[0].canonical) || samples.at(-1).visual !== null) evidence.failures.push(`Count canonical/final text changed: ${declared.id}`);
+      if (mode === "normal" && !runtimeState?.static && !samples.some((s) => s.visual !== null && s.visual !== s.canonical)) evidence.failures.push(`Count never changed its visual value: ${declared.id}`);
+      if (mode === "reduce" && samples.some((s) => s.visual !== null)) evidence.failures.push(`Reduced count animated: ${declared.id}`);
+    }
+    if (declared.effect === "draw" && mode === "normal" && !runtimeState?.static && new Set(samples.map((s) => s.stroke)).size < 2) evidence.failures.push(`Decorative path did not draw: ${declared.id}`);
+    if (["progress", "drift"].includes(declared.effect) && mode === "normal" && !runtimeState?.static) {
+      const states = [];
+      for (const progress of MOTION_SCENARIO.progress) {
+        const geometry = await target.evaluate((e) => {
+          const t = document.getElementById(e.getAttribute("data-motion-trigger") || "");
+          return { top: t.getBoundingClientRect().top + scrollY, height: t.getBoundingClientRect().height, start: Number(e.getAttribute("data-motion-range-start") || 0), end: Number(e.getAttribute("data-motion-range-end") || 1) };
+        });
+        const y = geometry.top - 900 + (900 + geometry.height) * (geometry.start + progress * (geometry.end - geometry.start));
+        const clamped = await page.evaluate((y2) => {
+          const max = document.documentElement.scrollHeight - innerHeight;
+          scrollTo(0, y2);
+          return y2 < 0 || y2 > max;
+        }, y);
+        await page.waitForTimeout(100);
+        await capture(`progress-${progress}`);
+        const actual = samples.at(-1).progress;
+        if (actual !== null) states.push(actual);
+        else evidence.failures.push(`Progress target did not provide current state: ${declared.id}`);
+        if (!clamped && actual !== null && Math.abs(actual - progress) > 0.04) evidence.failures.push(`Progress checkpoint mismatch ${declared.id}: expected ${progress}, saw ${actual}`);
+      }
+      if (states.length && states[0] > states.at(-1) + 0.01) evidence.failures.push(`Progress reversed unexpectedly: ${declared.id}`);
+      if (states.length > 1 && Math.max(...states) - Math.min(...states) > 0.1 && new Set(samples.filter((s) => s.state.startsWith("progress-")).map((s) => s.transform)).size < 2) evidence.failures.push(`Linked effect stayed static despite changing progress: ${declared.id}`);
+    }
+    evidence.targets.push({ id: declared.id, effect: declared.effect, samples });
+  }
+  await page.evaluate(() => scrollTo(0, 0));
+  return evidence;
+}
+function temporalMotionFailures(root, evidence, expectedAssetHash) {
+  const failures = [...evidence.failures];
+  if (evidence.scenarioHash !== MOTION_SCENARIO_HASH || evidence.engineAssetHash !== expectedAssetHash) failures.push("Temporal motion evidence uses stale scenarios or engine bytes");
+  for (const target of evidence.targets) for (const sample of target.samples) {
+    try {
+      const bytes = readFileSync4(join4(root, sample.screenshot));
+      if (![137, 80, 78, 71, 13, 10, 26, 10].every((value, i) => bytes[i] === value) || fingerprint(root, [sample.screenshot]) !== sample.screenshotHash) failures.push(`Motion capture corrupt or changed: ${sample.screenshot}`);
+    } catch {
+      failures.push(`Motion capture missing: ${sample.screenshot}`);
+    }
+  }
+  return failures;
+}
+
+export {
+  loadPlaywrightChromium,
+  explainBrowserLaunchFailure,
+  TEMPLATE_MOTION_PATH,
+  templateMotionHash,
+  validateTemplateMotionPlan,
+  templateMotionReviewFailures,
+  motionCompositionPolicy,
+  validateRouteComposition,
+  compositionBindingFailures,
+  captureMotionJourney,
+  journeyEvidenceFailures,
+  motionCritiqueFailures,
+  MOTION_SCENARIO_HASH,
+  observeMotion,
+  temporalMotionFailures
+};