@tempo-ai/mcp 0.0.105 → 0.0.106

package/dist/{serve-E62XRLQQ.js → serve-7RSR6WI6.js}

@@ -1342,8 +1342,8 @@ var require_utils = __commonJS({
       }
       return output;
     };
-    exports.basename = (path61, { windows } = {}) => {
-      const segs = path61.split(windows ? /[\\/]/ : "/");
+    exports.basename = (path62, { windows } = {}) => {
+      const segs = path62.split(windows ? /[\\/]/ : "/");
       const last2 = segs[segs.length - 1];
       if (last2 === "") {
         return segs[segs.length - 2];
@@ -3645,10 +3645,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path61, isFile, isDirectory) {
-      log(`checking %s`, path61);
+    function check(path62, isFile, isDirectory) {
+      log(`checking %s`, path62);
       try {
-        const stat11 = fs_1.statSync(path61);
+        const stat11 = fs_1.statSync(path62);
         if (stat11.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -3668,8 +3668,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists3(path61, type = exports.READABLE) {
-      return check(path61, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists3(path62, type = exports.READABLE) {
+      return check(path62, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists3;
     exports.FILE = 1;
@@ -5692,7 +5692,7 @@ var require_png = __commonJS({
     var Parser = require_parser_async();
     var Packer = require_packer_async();
     var PNGSync = require_png_sync();
-    var PNG4 = exports.PNG = function(options) {
+    var PNG5 = exports.PNG = function(options) {
       Stream.call(this);
       options = options || {};
       this.width = options.width | 0;
@@ -5721,9 +5721,9 @@ var require_png = __commonJS({
       this._parser.on("close", this._handleClose.bind(this));
       this._packer.on("error", this.emit.bind(this, "error"));
     };
-    util.inherits(PNG4, Stream);
-    PNG4.sync = PNGSync;
-    PNG4.prototype.pack = function() {
+    util.inherits(PNG5, Stream);
+    PNG5.sync = PNGSync;
+    PNG5.prototype.pack = function() {
       if (!this.data || !this.data.length) {
         this.emit("error", "No data provided");
         return this;
@@ -5735,7 +5735,7 @@ var require_png = __commonJS({
       );
       return this;
     };
-    PNG4.prototype.parse = function(data, callback) {
+    PNG5.prototype.parse = function(data, callback) {
       if (callback) {
         let onParsed, onError2;
         onParsed = function(parsedData) {
@@ -5753,27 +5753,27 @@ var require_png = __commonJS({
       this.end(data);
       return this;
     };
-    PNG4.prototype.write = function(data) {
+    PNG5.prototype.write = function(data) {
       this._parser.write(data);
       return true;
     };
-    PNG4.prototype.end = function(data) {
+    PNG5.prototype.end = function(data) {
       this._parser.end(data);
     };
-    PNG4.prototype._metadata = function(metadata) {
+    PNG5.prototype._metadata = function(metadata) {
       this.width = metadata.width;
       this.height = metadata.height;
       this.emit("metadata", metadata);
     };
-    PNG4.prototype._gamma = function(gamma) {
+    PNG5.prototype._gamma = function(gamma) {
       this.gamma = gamma;
     };
-    PNG4.prototype._handleClose = function() {
+    PNG5.prototype._handleClose = function() {
       if (!this._parser.writable && !this._packer.readable) {
         this.emit("close");
       }
     };
-    PNG4.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) {
+    PNG5.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) {
       srcX |= 0;
       srcY |= 0;
       width |= 0;
@@ -5795,11 +5795,11 @@ var require_png = __commonJS({
         );
       }
     };
-    PNG4.prototype.bitblt = function(dst, srcX, srcY, width, height, deltaX, deltaY) {
-      PNG4.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
+    PNG5.prototype.bitblt = function(dst, srcX, srcY, width, height, deltaX, deltaY) {
+      PNG5.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
       return this;
     };
-    PNG4.adjustGamma = function(src) {
+    PNG5.adjustGamma = function(src) {
       if (src.gamma) {
         for (let y = 0; y < src.height; y++) {
           for (let x = 0; x < src.width; x++) {
@@ -5814,8 +5814,8 @@ var require_png = __commonJS({
         src.gamma = 0;
       }
     };
-    PNG4.prototype.adjustGamma = function() {
-      PNG4.adjustGamma(this);
+    PNG5.prototype.adjustGamma = function() {
+      PNG5.adjustGamma(this);
     };
   }
 });
@@ -5986,7 +5986,7 @@ var TOOL_MANIFEST = [
   // ── linear (4) ──────────────────────────────────────────────────────────
   ...read("linear", ["linear_search_issues", "linear_get_issue"]),
   ...write("linear", ["linear_update_issue", "linear_add_comment"]),
-  // ── canvas (29) ─────────────────────────────────────────────────────────
+  // ── canvas (30) ─────────────────────────────────────────────────────────
   // File/workspace tools — work anywhere the repo checkout lives.
   ...read("canvas", [
     "canvas_validate",
@@ -6011,7 +6011,7 @@ var TOOL_MANIFEST = [
   // Visual tools — powered externally by the headless capture hooks
   // (disposable devserver + Playwright); error actionably when Chromium
   // is not installed.
-  ...read("canvas", ["canvas_screenshot"]),
+  ...read("canvas", ["canvas_screenshot", "canvas_verify_vrt"]),
   ...write("canvas", ["canvas_share"]),
   // App-internal surface: devserver supervision is the CLI's own plumbing
   // (spawned per capture), and the editing-lock bookends coordinate the
@@ -6443,8 +6443,8 @@ var STAGE_RANK_END = Number.MAX_SAFE_INTEGER;
 // ../issues-core/share-url.ts
 function buildIssueShareUrl(baseUrl, orgSlugOrId, humanId, titleSlug) {
   const base = `/${encodeURIComponent(orgSlugOrId)}/issues/${encodeURIComponent(humanId)}`;
-  const path61 = titleSlug ? `${base}/${encodeURIComponent(titleSlug)}` : base;
-  const u = new URL(path61, baseUrl);
+  const path62 = titleSlug ? `${base}/${encodeURIComponent(titleSlug)}` : base;
+  const u = new URL(path62, baseUrl);
   return u.toString();
 }
 
@@ -7916,19 +7916,19 @@ function normalizeRepoUrl(url) {
   const sshMatch = cleaned.match(sshShorthand);
   if (sshMatch) {
     const host = sshMatch[1];
-    const path61 = sshMatch[2];
-    return finalize(host, path61);
+    const path62 = sshMatch[2];
+    return finalize(host, path62);
   }
   const protocolMatch = cleaned.match(/^[\w+.-]+:\/\/(?:[^@]+@)?([\w.-]+)\/([\w./-]+)$/);
   if (protocolMatch) {
     const host = protocolMatch[1];
-    const path61 = protocolMatch[2];
-    return finalize(host, path61);
+    const path62 = protocolMatch[2];
+    return finalize(host, path62);
   }
   return null;
 }
-function finalize(host, path61) {
-  let cleaned = path61.replace(/\.git$/, "");
+function finalize(host, path62) {
+  let cleaned = path62.replace(/\.git$/, "");
   cleaned = cleaned.replace(/^\/+|\/+$/g, "");
   if (!cleaned) return null;
   return `${host}/${cleaned}`.toLowerCase();
@@ -9528,8 +9528,8 @@ var api2 = anyApi2;
 // ../doc-editor/src/client/docShareUrl.ts
 function buildDocShareUrl(baseUrl, orgSlugOrId, docId, titleSlug) {
   const base = `/${encodeURIComponent(orgSlugOrId)}/docs/${encodeURIComponent(docId)}`;
-  const path61 = titleSlug ? `${base}/${encodeURIComponent(titleSlug)}` : base;
-  return new URL(path61, baseUrl).toString();
+  const path62 = titleSlug ? `${base}/${encodeURIComponent(titleSlug)}` : base;
+  return new URL(path62, baseUrl).toString();
 }
 
 // ../doc-editor/mcp/tools/read.ts
@@ -16954,6 +16954,7 @@ Screenshot ONE representative storyboard you actually edited \u2014 not every st
 - A \`canvas_not_open\` error means the user does not have any canvas open in the Design tab. Stop calling \`canvas_screenshot\`, tell the user to open the canvas, and move on \u2014 firing more screenshots will not change the outcome.
 - Any typed error (\`storyboard_not_found\`, \`storyboard_empty\`, \`capture_timeout\`, \`capture_threw\`, \`canvas_mismatch\`, \`capture_unsupported\`) \u2014 one try per storyboard. Don't retry, don't broaden to other storyboards, don't fire a second wave. **One exception:** a route storyboard's \`capture_threw\` "could not be cold-captured" means the app dev server isn't running \u2014 call \`start_app_dev_server\` once, then a single retry is warranted (better, pre-flight per the route-storyboard rule above so it never fails).
 - If you need to understand the failure, call \`canvas_debug({ canvas_slug, storyboard? })\` once and inspect the diagnostics instead of repeatedly calling \`canvas_screenshot\`.
+- \`canvas_verify_vrt\` adds its own typed errors, also one try each: \`storyboard_not_tested\` (add a literal \`vrt\` prop first), \`storyboard_paused\` (remove \`skip: true\` before verifying), \`storyboard_unsupported\` (route/HTML storyboards are not verified \u2014 component storyboards only), \`storyboard_invalid\` (parse error, or \`vrt.ignore\` masks \u226590% of the board), \`capture_incomplete\` / \`compare_failed\` (the batch or the pixel comparison broke \u2014 \`canvas_debug\` once), \`determinism_setup_failed\` (the browser could not install frozen clocks/timezone \u2014 an environment problem, not the storyboard's). An \`unstable\` verdict is NOT an error: fix the nondeterministic input and rerun.
 
 Quality checklist:
 
@@ -16978,6 +16979,27 @@ For UI that already exists, measure instead of guessing:
 
 ---
 
+## 9.2 VRT stability (\`canvas_verify_vrt\`)
+
+A storyboard carrying the literal \`vrt\` prop is a **tested** storyboard: the visual-review workflow captures it on every push and diffs it against a baseline. A tested storyboard that renders differently on each mount (live clocks, \`Math.random\`, unseeded fixtures, in-flight animation, network-dependent content) flakes the \`visual-review\` status for every PR after yours. So after adding or changing \`vrt\`, run
+
+\`\`\`
+canvas_verify_vrt({ canvas_slug, storyboard })
+\`\`\`
+
+once per tested storyboard you touched, and keep it in the same session as the edit.
+
+What it does: one capture session, \`runs\` (default 3, max 10) fresh isolated mounts at full resolution, each compared with run 1 under the exact visual-review policy \u2014 VRT's frozen clocks, seeded randomness and motion controls on the render side; the same AA-tolerant pixel matcher, the storyboard's \`threshold\` (default 0.1), and its \`ignore\` masks on the compare side. Nothing is retained between runs except run 1 and the running diff. It measures rendered output only; it never reads or edits source.
+
+Reading the result \u2014 only \`vrt_stable\` matters:
+
+- \`vrt_stable: true\` \u2014 done; the baseline will hold.
+- \`vrt_stable: false\` \u2014 the response carries \`diff_bounds_device_px\` (union of every change, in device pixels), per-run \`comparisons\`, and a fuchsia **diff-mask image** (transparent = stable, fuchsia = changed in at least one run; masks wider than 1990px are area-resampled so a one-pixel flicker still shows, while the JSON bounds stay in original device pixels). Use the region to walk the storyboard's component dependency graph for the nondeterministic input, replace it with fixed storyboard props / fixtures / a seeded source, and rerun. Raise \`runs\` for a flake that only shows one time in five.
+
+It accepts only ACTIVE tested component storyboards: no \`vrt\` prop, \`vrt={{ skip: true }}\`, route storyboards, and HTML storyboards are all refused with a typed error (codes in the stop-conditions list above). Like \`canvas_screenshot\`, it fails fast with \`capacity_exceeded\` when every managed devserver slot is pinned \u2014 continue and tell the user to rerun rather than looping.
+
+---
+
 ## 10. Constraints
 
 - No UUIDs, no JSON canvas configs
@@ -17905,9 +17927,9 @@ function buildCanvasInstructions(canvasesDir, options) {
 Before creating, modifying, restyling, or reviewing ANY UI, call \`asset_list\` FIRST and reuse results per \`usageInstructions\`. Do the same for design system, component library, or UI kit requests; use \`asset_list_libraries\` for a collection overview. To ADD or EDIT asset declarations, FIRST call get_guide({ topic: "tempo-assets-instructions" }) \u2014 \`defineAsset\` declares the TOP-LEVEL component consumers import (\`Select\`, never \`SelectTrigger\`).
 
 `;
-  return `Tempo's "Design" tab is a code-first Figma alternative. Canvases live under the canvases root ${canvasesDir}/, whose storyboards render PRODUCTION components and routes \u2014 never mocks of existing UI.
+  return `Tempo canvases are code-first. Canvases live under the canvases root ${canvasesDir}/, whose storyboards render PRODUCTION components and routes \u2014 never mocks of existing UI.
 
-Before any canvas change \u2014 including tempo.config.json edits (Docker, custom launchers, ports) \u2014 you MUST call get_guide({ topic: "tempo-canvas-instructions" }); it holds every protocol and overrides this summary.
+Before any canvas or tempo.config.json change, you MUST call get_guide({ topic: "tempo-canvas-instructions" }); it is authoritative.
 
 ${assetLibrarySection}## Hard invariants
 
@@ -17916,12 +17938,13 @@ ${assetLibrarySection}## Hard invariants
 - Bookend every canvas session: start_working_on_canvas BEFORE the first mutating call (canvas_create included) \u2192 edits \u2192 canvas_screenshot on ONE edited storyboard \u2192 finish_working_on_canvas once. On screenshot failure: canvas_debug once, no retries.
 - Write is blocked on *.canvas.tsx \u2014 canvas_create creates, Edit modifies.
 - Route storyboards need the user's real app: set_app_dev_command once, start_app_dev_server before screenshots.
+- After adding/changing \`vrt\`, run canvas_verify_vrt; fix nondeterminism and rerun until \`vrt_stable\`.
 - Replicating existing UI (live page, Browser tab, URL)? Pixel parity is the goal: capture its screenshot/HTML/styles via the CDP endpoint, loop canvas_screenshot against it \u2014 guide \xA79.1.
 - Link new canvases to sibling issue/doc via link_items (branch pushed).`;
 }
 
 // ../canvas-mcp/tools.ts
-import path54 from "path";
+import path55 from "path";
 
 // ../asset-libraries/mcp/tools.ts
 import { readFile as readFile4, writeFile } from "fs/promises";
@@ -19782,7 +19805,7 @@ function parseCanvasFile(filePath, source) {
     "name",
     objectStringBindings
   );
-  const path61 = readStringAttribute(openingElement, "path");
+  const path62 = readStringAttribute(openingElement, "path");
   const backgroundColor = readResolvableStringAttribute(
     openingElement,
     "backgroundColor",
@@ -19801,7 +19824,7 @@ function parseCanvasFile(filePath, source) {
   }
   return {
     filePath,
-    canvasPath: path61?.value,
+    canvasPath: path62?.value,
     pageName: name?.value ?? fallbackPageName(filePath),
     backgroundColor: backgroundColor?.value,
     canvasElementSpan: toSpan(canvasElement),
@@ -19809,8 +19832,8 @@ function parseCanvasFile(filePath, source) {
     canvasChildrenInsertionOffset: typeof canvasElement?.closingElement?.start === "number" ? canvasElement.closingElement.start : void 0,
     nameSpan: name?.valueSpan,
     nameAttributeSpan: name?.attributeSpan,
-    pathSpan: path61?.valueSpan,
-    pathAttributeSpan: path61?.attributeSpan,
+    pathSpan: path62?.valueSpan,
+    pathAttributeSpan: path62?.attributeSpan,
     backgroundColorSpan: backgroundColor?.valueSpan,
     backgroundColorAttributeSpan: backgroundColor?.attributeSpan,
     imports: imports.all,
@@ -20678,7 +20701,7 @@ function adaptReactCanvasPage(filePath, source) {
         ...storyboard.route ? { route: storyboard.route } : {},
         ...storyboard.filepath ? { filepath: storyboard.filepath } : {},
         ...storyboard.src ? { src: storyboard.src } : {},
-        ...storyboard.vrt ? { vrt: true } : {},
+        ...storyboard.vrt ? { vrt: true, vrtConfig: storyboard.vrt } : {},
         layoutSpans: toLegacyLayoutSpans(storyboard.layoutSpans),
         ...storyboard.errors.length > 0 ? {
           error: storyboard.errors.map((error) => error.message).join("; ")
@@ -22474,7 +22497,7 @@ function createQueuedFileEditor() {
     };
     return runAtIndex(0);
   }
-  async function readFile26(absolutePath) {
+  async function readFile27(absolutePath) {
     return withFileLock(absolutePath, () => readFileUnlocked(absolutePath));
   }
   async function readBinaryFile(absolutePath) {
@@ -22560,7 +22583,7 @@ function createQueuedFileEditor() {
     });
   }
   return {
-    readFile: readFile26,
+    readFile: readFile27,
     readBinaryFile,
     readFileIfExists,
     writeFile: writeFile11,
@@ -22572,7 +22595,7 @@ function createQueuedFileEditor() {
     unlinkFile,
     withFileLock,
     withFileLocks,
-    readWorkspaceFile: (workspacePath, relativePath) => readFile26(resolveWorkspaceRelativePath(workspacePath, relativePath)),
+    readWorkspaceFile: (workspacePath, relativePath) => readFile27(resolveWorkspaceRelativePath(workspacePath, relativePath)),
     readWorkspaceFileIfExists: (workspacePath, relativePath) => readFileIfExists(resolveWorkspaceRelativePath(workspacePath, relativePath)),
     writeWorkspaceFile: (workspacePath, relativePath, content, expectedMtime, nextMtime) => writeFile11(
       resolveWorkspaceRelativePath(workspacePath, relativePath),
@@ -24580,8 +24603,8 @@ function extractImporterFromLine(line) {
   }
   return null;
 }
-function normalizeImporterPath(path61) {
-  return path61.replace(/^\.\//, "");
+function normalizeImporterPath(path62) {
+  return path62.replace(/^\.\//, "");
 }
 
 // ../tempo-devserver/port-listener.ts
@@ -26718,10 +26741,10 @@ async function scanTree(realRoot, ignorePaths = []) {
   for (let i = 0; i < pendingStats.length; i += STAT_CONCURRENCY) {
     const slice = pendingStats.slice(i, i + STAT_CONCURRENCY);
     await Promise.all(
-      slice.map(async (path61) => {
+      slice.map(async (path62) => {
         try {
-          const st = await lstat(path61);
-          scan.set(path61, {
+          const st = await lstat(path62);
+          scan.set(path62, {
             mtimeMs: st.mtimeMs,
             size: st.size,
             isDir: false
@@ -26735,16 +26758,16 @@ async function scanTree(realRoot, ignorePaths = []) {
 }
 function diffScans(previous, next) {
   const events = [];
-  for (const [path61, now] of next) {
-    const before = previous.get(path61);
+  for (const [path62, now] of next) {
+    const before = previous.get(path62);
     if (!before) {
-      events.push({ path: path61, type: "create" });
+      events.push({ path: path62, type: "create" });
     } else if (!now.isDir && (before.mtimeMs !== now.mtimeMs || before.size !== now.size)) {
-      events.push({ path: path61, type: "update" });
+      events.push({ path: path62, type: "update" });
     }
   }
-  for (const path61 of previous.keys()) {
-    if (!next.has(path61)) events.push({ path: path61, type: "delete" });
+  for (const path62 of previous.keys()) {
+    if (!next.has(path62)) events.push({ path: path62, type: "delete" });
   }
   return events;
 }
@@ -27229,7 +27252,7 @@ async function parcelEventToFileEvent(event, rootInfo) {
 // ../tempo-sdk/package.json
 var package_default = {
   name: "tempo-sdk",
-  version: "0.0.37",
+  version: "0.0.38",
   type: "module",
   description: "Tempo SDK \u2014 Vite, Next.js, and Expo plugins for JSX annotation and shared page/storyboard types",
   repository: {
@@ -33962,8 +33985,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path61) {
-  return path61 instanceof String && cache.has(path61);
+function isPathSpec(path62) {
+  return path62 instanceof String && cache.has(path62);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -34052,8 +34075,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path61) {
-  return (0, import_file_exists.exists)(path61, import_file_exists.FOLDER);
+function folderExists(path62) {
+  return (0, import_file_exists.exists)(path62, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -34457,8 +34480,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path61) {
-      return /^\.(git)?$/.test(path61.trim());
+    parser(path62) {
+      return /^\.(git)?$/.test(path62.trim());
     }
   };
 }
@@ -34892,11 +34915,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path61, line, preview] = input.split(NULL);
-    paths.add(path61);
-    (results[path61] = results[path61] || []).push({
+    const [path62, line, preview] = input.split(NULL);
+    paths.add(path62);
+    (results[path62] = results[path62] || []).push({
       line: asNumber(line),
-      path: path61,
+      path: path62,
       preview
     });
   });
@@ -35661,14 +35684,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path61, text) {
+function parseInit(bare, path62, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path61, false, result[1]);
+    return new InitSummary(bare, path62, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path61, true, result[1]);
+    return new InitSummary(bare, path62, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -35679,7 +35702,7 @@ function parseInit(bare, path61, text) {
       break;
     }
   }
-  return new InitSummary(bare, path61, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path62, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -35688,9 +35711,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path61, existing, gitDir) {
+      constructor(bare, path62, existing, gitDir) {
         this.bare = bare;
-        this.path = path61;
+        this.path = path62;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -35702,7 +35725,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path61, customArgs) {
+function initTask(bare = false, path62, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -35711,7 +35734,7 @@ function initTask(bare = false, path61, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path61, text);
+      return parseInit(commands.includes("--bare"), path62, text);
     }
   };
 }
@@ -36527,12 +36550,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path61, index, working_dir) {
-        this.path = path61;
+      constructor(path62, index, working_dir) {
+        this.path = path62;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path61) || [null, path61, path61];
+          const detail = fromPathRegex.exec(path62) || [null, path62, path62];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -36563,14 +36586,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path61) {
+  function data(index, workingDir, path62) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path61);
+      handler(result, path62);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path61, index, workingDir));
+      result.files.push(new FileStatusSummary(path62, index, workingDir));
     }
   }
 }
@@ -36879,9 +36902,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path61, write2) {
+      hashObject(path62, write2) {
         return this._runTask(
-          hashObjectTask(path61, write2 === true),
+          hashObjectTask(path62, write2 === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -37234,8 +37257,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path61 = input.trim().replace(/^["']|["']$/g, "");
-  return path61 && normalize(path61);
+  const path62 = input.trim().replace(/^["']|["']$/g, "");
+  return path62 && normalize(path62);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -37549,8 +37572,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path61) {
-  return subModuleTask(["add", repo, path61]);
+function addSubModuleTask(repo, path62) {
+  return subModuleTask(["add", repo, path62]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -37883,8 +37906,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path61, then) {
-      return this._runTask(addSubModuleTask2(repo, path61), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path62, then) {
+      return this._runTask(addSubModuleTask2(repo, path62), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -42412,17 +42435,17 @@ var APP_LAYOUT_CANDIDATES = [
   "src/app/layout.js"
 ];
 var PAGES_DIRECTORY_CANDIDATES = ["pages", "src/pages"];
-async function fileExists3(path61) {
+async function fileExists3(path62) {
   try {
-    await access11(path61);
+    await access11(path62);
     return true;
   } catch {
     return false;
   }
 }
-async function directoryExists(path61) {
+async function directoryExists(path62) {
   try {
-    const stats = await stat6(path61);
+    const stats = await stat6(path62);
     return stats.isDirectory();
   } catch {
     return false;
@@ -42559,9 +42582,9 @@ var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
 ]);
 var DEFAULT_SCAN_ROOTS = ["apps", "packages"];
 var MAX_SCAN_DEPTH = 8;
-async function pathExists9(path61) {
+async function pathExists9(path62) {
   try {
-    await access12(path61);
+    await access12(path62);
     return true;
   } catch {
     return false;
@@ -42696,9 +42719,9 @@ var LOCK_FILE_PRIORITY = [
     packageManager: PackageManager.NPM
   }
 ];
-async function fileExists4(path61) {
+async function fileExists4(path62) {
   try {
-    await access13(path61);
+    await access13(path62);
     return true;
   } catch {
     return false;
@@ -42749,9 +42772,9 @@ var VITE_CONFIG_FILES = [
   "vite.config.mjs",
   "vite.config.mts"
 ];
-async function fileExists5(path61) {
+async function fileExists5(path62) {
   try {
-    await access14(path61);
+    await access14(path62);
     return true;
   } catch {
     return false;
@@ -45041,6 +45064,558 @@ async function runCanvasValidation(args, options) {
   };
 }
 
+// ../canvas-mcp/storyboard-stability.ts
+import { readFile as readFile24 } from "fs/promises";
+import path54 from "path";
+
+// ../../node_modules/.pnpm/pixelmatch@7.1.0/node_modules/pixelmatch/index.js
+function pixelmatch(img1, img2, output, width, height, options = {}) {
+  const {
+    threshold = 0.1,
+    alpha = 0.1,
+    aaColor = [255, 255, 0],
+    diffColor = [255, 0, 0],
+    includeAA,
+    diffColorAlt,
+    diffMask
+  } = options;
+  if (!isPixelData(img1) || !isPixelData(img2) || output && !isPixelData(output))
+    throw new Error("Image data: Uint8Array, Uint8ClampedArray or Buffer expected.");
+  if (img1.length !== img2.length || output && output.length !== img1.length)
+    throw new Error("Image sizes do not match.");
+  if (img1.length !== width * height * 4) throw new Error("Image data size does not match width/height.");
+  const len = width * height;
+  const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
+  const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
+  let identical = true;
+  for (let i = 0; i < len; i++) {
+    if (a32[i] !== b32[i]) {
+      identical = false;
+      break;
+    }
+  }
+  if (identical) {
+    if (output && !diffMask) {
+      for (let i = 0; i < len; i++) drawGrayPixel(img1, 4 * i, alpha, output);
+    }
+    return 0;
+  }
+  const maxDelta = 35215 * threshold * threshold;
+  const [aaR, aaG, aaB] = aaColor;
+  const [diffR, diffG, diffB] = diffColor;
+  const [altR, altG, altB] = diffColorAlt || diffColor;
+  let diff = 0;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = y * width + x;
+      const pos = i * 4;
+      const delta = a32[i] === b32[i] ? 0 : colorDelta(img1, img2, pos, pos, false);
+      if (Math.abs(delta) > maxDelta) {
+        const isAA = antialiased(img1, x, y, width, height, a32, b32) || antialiased(img2, x, y, width, height, b32, a32);
+        if (!includeAA && isAA) {
+          if (output && !diffMask) drawPixel(output, pos, aaR, aaG, aaB);
+        } else {
+          if (output) {
+            if (delta < 0) {
+              drawPixel(output, pos, altR, altG, altB);
+            } else {
+              drawPixel(output, pos, diffR, diffG, diffB);
+            }
+          }
+          diff++;
+        }
+      } else if (output && !diffMask) {
+        drawGrayPixel(img1, pos, alpha, output);
+      }
+    }
+  }
+  return diff;
+}
+function isPixelData(arr) {
+  return ArrayBuffer.isView(arr) && arr.BYTES_PER_ELEMENT === 1;
+}
+function antialiased(img, x1, y1, width, height, a32, b32) {
+  const x0 = Math.max(x1 - 1, 0);
+  const y0 = Math.max(y1 - 1, 0);
+  const x2 = Math.min(x1 + 1, width - 1);
+  const y2 = Math.min(y1 + 1, height - 1);
+  const pos = y1 * width + x1;
+  let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+  let min = 0;
+  let max = 0;
+  let minX = 0;
+  let minY = 0;
+  let maxX = 0;
+  let maxY = 0;
+  for (let x = x0; x <= x2; x++) {
+    for (let y = y0; y <= y2; y++) {
+      if (x === x1 && y === y1) continue;
+      const delta = colorDelta(img, img, pos * 4, (y * width + x) * 4, true);
+      if (delta === 0) {
+        zeroes++;
+        if (zeroes > 2) return false;
+      } else if (delta < min) {
+        min = delta;
+        minX = x;
+        minY = y;
+      } else if (delta > max) {
+        max = delta;
+        maxX = x;
+        maxY = y;
+      }
+    }
+  }
+  if (min === 0 || max === 0) return false;
+  return hasManySiblings(a32, minX, minY, width, height) && hasManySiblings(b32, minX, minY, width, height) || hasManySiblings(a32, maxX, maxY, width, height) && hasManySiblings(b32, maxX, maxY, width, height);
+}
+function hasManySiblings(img, x1, y1, width, height) {
+  const x0 = Math.max(x1 - 1, 0);
+  const y0 = Math.max(y1 - 1, 0);
+  const x2 = Math.min(x1 + 1, width - 1);
+  const y2 = Math.min(y1 + 1, height - 1);
+  const val = img[y1 * width + x1];
+  let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+  for (let x = x0; x <= x2; x++) {
+    for (let y = y0; y <= y2; y++) {
+      if (x === x1 && y === y1) continue;
+      zeroes += +(val === img[y * width + x]);
+      if (zeroes > 2) return true;
+    }
+  }
+  return false;
+}
+function colorDelta(img1, img2, k2, m, yOnly) {
+  const r1 = img1[k2];
+  const g1 = img1[k2 + 1];
+  const b1 = img1[k2 + 2];
+  const a1 = img1[k2 + 3];
+  const r2 = img2[m];
+  const g2 = img2[m + 1];
+  const b2 = img2[m + 2];
+  const a2 = img2[m + 3];
+  let dr = r1 - r2;
+  let dg = g1 - g2;
+  let db = b1 - b2;
+  const da = a1 - a2;
+  if (!dr && !dg && !db && !da) return 0;
+  if (a1 < 255 || a2 < 255) {
+    const rb = 48 + 159 * (k2 % 2);
+    const gb = 48 + 159 * ((k2 / 1.618033988749895 | 0) % 2);
+    const bb = 48 + 159 * ((k2 / 2.618033988749895 | 0) % 2);
+    dr = (r1 * a1 - r2 * a2 - rb * da) / 255;
+    dg = (g1 * a1 - g2 * a2 - gb * da) / 255;
+    db = (b1 * a1 - b2 * a2 - bb * da) / 255;
+  }
+  const y = dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
+  if (yOnly) return y;
+  const i = dr * 0.59597799 - dg * 0.2741761 - db * 0.32180189;
+  const q = dr * 0.21147017 - dg * 0.52261711 + db * 0.31114694;
+  const delta = 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
+  return y > 0 ? -delta : delta;
+}
+function drawPixel(output, pos, r, g, b2) {
+  output[pos + 0] = r;
+  output[pos + 1] = g;
+  output[pos + 2] = b2;
+  output[pos + 3] = 255;
+}
+function drawGrayPixel(img, i, alpha, output) {
+  const val = 255 + (img[i] * 0.29889531 + img[i + 1] * 0.58662247 + img[i + 2] * 0.11448223 - 255) * alpha * img[i + 3] / 255;
+  drawPixel(output, i, val, val, val);
+}
+
+// ../canvas-mcp/storyboard-stability.ts
+var import_pngjs = __toESM(require_png(), 1);
+var DEFAULT_VRT_PIXEL_THRESHOLD = 0.1;
+var MAX_STABILITY_DIFF_DIMENSION_PX = 1990;
+var StoryboardStabilityTargetError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "StoryboardStabilityTargetError";
+    this.code = code;
+  }
+};
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function absoluteCanvasesRoot(workspaceRoot, canvasesDir) {
+  return path54.isAbsolute(canvasesDir) ? path54.resolve(canvasesDir) : path54.resolve(workspaceRoot, canvasesDir);
+}
+async function resolveCanvasFile(options) {
+  const canvasesRoot = absoluteCanvasesRoot(
+    options.workspaceRoot,
+    options.canvasesDir
+  );
+  const identifier = options.canvasSlug;
+  const resolved = /* @__PURE__ */ new Set();
+  const direct = await resolveCanvasFilePath(
+    path54.join(canvasesRoot, identifier)
+  );
+  if (direct) resolved.add(direct);
+  if (resolved.size === 0 && !identifier.includes("/")) {
+    const files = await findPageFilesInPagesRoot(canvasesRoot);
+    for (const file of files) {
+      if (path54.basename(path54.dirname(file)) === identifier) resolved.add(file);
+    }
+  }
+  if (resolved.size === 0) {
+    throw new StoryboardStabilityTargetError(
+      "canvas_not_found",
+      `No canvas matching "${options.canvasSlug}" exists under ${toPosix(canvasesRoot)}.`
+    );
+  }
+  if (resolved.size > 1) {
+    const candidates = [...resolved].map((file) => toPosix(path54.relative(canvasesRoot, path54.dirname(file)))).sort();
+    throw new StoryboardStabilityTargetError(
+      "ambiguous_canvas_slug",
+      `"${options.canvasSlug}" names ${candidates.length} canvases: ${candidates.join(", ")}. Pass the full canvases-root-relative path.`
+    );
+  }
+  const canvasFile = resolved.values().next().value;
+  if (!canvasFile) {
+    throw new StoryboardStabilityTargetError(
+      "canvas_not_found",
+      `No canvas matching "${options.canvasSlug}" exists under ${toPosix(canvasesRoot)}.`
+    );
+  }
+  return canvasFile;
+}
+async function resolveTestedStoryboard(options) {
+  const canvasFile = await resolveCanvasFile(options);
+  const source = await readFile24(canvasFile, "utf8");
+  const parsed = parsePageSource(canvasFile, source);
+  const storyboard = parsed.storyboards.find(
+    (candidate) => candidate.storyboardKey === options.storyboard || candidate.exportName === options.storyboard
+  );
+  if (!storyboard) {
+    const available = parsed.storyboards.map((candidate) => candidate.storyboardKey ?? candidate.exportName).join(", ");
+    throw new StoryboardStabilityTargetError(
+      "storyboard_not_found",
+      `Storyboard "${options.storyboard}" was not found in ${toPosix(path54.relative(options.workspaceRoot, canvasFile))}.${available ? ` Available storyboards: ${available}.` : ""}`
+    );
+  }
+  if (storyboard.error) {
+    throw new StoryboardStabilityTargetError(
+      "storyboard_invalid",
+      `Storyboard "${options.storyboard}" cannot be verified: ${storyboard.error}`
+    );
+  }
+  if (storyboard.isRoute || storyboard.isHtml) {
+    throw new StoryboardStabilityTargetError(
+      "storyboard_unsupported",
+      `Storyboard "${options.storyboard}" is not a component storyboard; VRT stability verification currently supports component storyboards only.`
+    );
+  }
+  if (!storyboard.vrt || !storyboard.vrtConfig) {
+    throw new StoryboardStabilityTargetError(
+      "storyboard_not_tested",
+      `Storyboard "${options.storyboard}" is not VRT-tested. Add a literal vrt prop before verifying stability.`
+    );
+  }
+  if (storyboard.vrtConfig.skip) {
+    throw new StoryboardStabilityTargetError(
+      "storyboard_paused",
+      `Storyboard "${options.storyboard}" is paused with vrt={{ skip: true }}. Remove skip before verifying it as an active test.`
+    );
+  }
+  const maskedArea = (storyboard.vrtConfig.ignore ?? []).reduce(
+    (sum, region) => sum + region.w * region.h,
+    0
+  );
+  if (maskedArea >= 0.9 * storyboard.layout.width * storyboard.layout.height) {
+    throw new StoryboardStabilityTargetError(
+      "storyboard_invalid",
+      `Storyboard "${options.storyboard}" has vrt.ignore masking at least 90% of its area; VRT rejects this configuration.`
+    );
+  }
+  return {
+    canvasFile: toPosix(path54.relative(options.workspaceRoot, canvasFile)),
+    canvasSlug: toPosix(
+      path54.relative(
+        absoluteCanvasesRoot(options.workspaceRoot, options.canvasesDir),
+        path54.dirname(canvasFile)
+      )
+    ),
+    storyboardId: storyboard.storyboardKey ?? storyboard.exportName,
+    layout: {
+      width: storyboard.layout.width,
+      height: storyboard.layout.height
+    },
+    vrt: storyboard.vrtConfig
+  };
+}
+function maskRegion(image, region) {
+  const x0 = Math.max(0, Math.floor(region.x));
+  const y0 = Math.max(0, Math.floor(region.y));
+  const x1 = Math.min(image.width, Math.ceil(region.x + region.w));
+  const y1 = Math.min(image.height, Math.ceil(region.y + region.h));
+  for (let y = y0; y < y1; y += 1) {
+    for (let x = x0; x < x1; x += 1) {
+      const offset = image.width * y + x << 2;
+      image.data[offset] = 0;
+      image.data[offset + 1] = 0;
+      image.data[offset + 2] = 0;
+      image.data[offset + 3] = 255;
+    }
+  }
+}
+function findDiffBounds(diff) {
+  let minX = diff.width;
+  let minY = diff.height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < diff.height; y += 1) {
+    for (let x = 0; x < diff.width; x += 1) {
+      if (diff.data[(diff.width * y + x << 2) + 3] === 0) continue;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  }
+  return maxX < minX || maxY < minY ? null : {
+    x: minX,
+    y: minY,
+    width: maxX - minX + 1,
+    height: maxY - minY + 1
+  };
+}
+function unionBounds(left, right) {
+  if (!left) return right;
+  if (!right) return left;
+  const x = Math.min(left.x, right.x);
+  const y = Math.min(left.y, right.y);
+  const x1 = Math.max(left.x + left.width, right.x + right.width);
+  const y1 = Math.max(left.y + left.height, right.y + right.height);
+  return { x, y, width: x1 - x, height: y1 - y };
+}
+function decodeCapture(capture) {
+  const image = import_pngjs.PNG.sync.read(Buffer.from(capture.pngBase64, "base64"));
+  if (image.width !== capture.width || image.height !== capture.height) {
+    throw new Error(
+      `Capture metadata ${capture.width}x${capture.height} does not match decoded PNG ${image.width}x${image.height}.`
+    );
+  }
+  return image;
+}
+function compareCaptureToBaseline(baseline, capture, run, options) {
+  const candidate = decodeCapture(capture);
+  if (candidate.width !== baseline.width || candidate.height !== baseline.height) {
+    const width = Math.max(baseline.width, candidate.width);
+    const height = Math.max(baseline.height, candidate.height);
+    const diff2 = new import_pngjs.PNG({ width, height });
+    for (let offset = 0; offset < diff2.data.length; offset += 4) {
+      diff2.data[offset] = 217;
+      diff2.data[offset + 1] = 70;
+      diff2.data[offset + 2] = 239;
+      diff2.data[offset + 3] = 255;
+    }
+    return {
+      diff: diff2,
+      comparison: {
+        run,
+        baselineRun: 1,
+        diffPixels: candidate.width * candidate.height,
+        diffRatio: 1,
+        diffBounds: { x: 0, y: 0, width, height },
+        dimensions: { width: candidate.width, height: candidate.height },
+        dimensionChange: {
+          baseline: { width: baseline.width, height: baseline.height },
+          candidate: { width: candidate.width, height: candidate.height }
+        }
+      }
+    };
+  }
+  const scaleX = baseline.width / options.layout.width;
+  const scaleY = baseline.height / options.layout.height;
+  for (const region of options.ignore) {
+    const scaled = {
+      x: region.x * scaleX,
+      y: region.y * scaleY,
+      w: region.w * scaleX,
+      h: region.h * scaleY
+    };
+    maskRegion(candidate, scaled);
+  }
+  const diff = new import_pngjs.PNG({ width: baseline.width, height: baseline.height });
+  const diffPixels = pixelmatch(
+    baseline.data,
+    candidate.data,
+    diff.data,
+    baseline.width,
+    baseline.height,
+    {
+      threshold: options.threshold,
+      includeAA: false,
+      diffMask: true,
+      diffColor: [217, 70, 239]
+    }
+  );
+  return {
+    diff,
+    comparison: {
+      run,
+      baselineRun: 1,
+      diffPixels,
+      diffRatio: diffPixels / (baseline.width * baseline.height),
+      diffBounds: findDiffBounds(diff),
+      dimensions: { width: candidate.width, height: candidate.height }
+    }
+  };
+}
+function mergeDiffImage(current, next) {
+  const width = Math.max(current?.width ?? 0, next.width);
+  const height = Math.max(current?.height ?? 0, next.height);
+  const merged = current && current.width === width && current.height === height ? current : new import_pngjs.PNG({ width, height });
+  const merge = (source) => {
+    for (let y = 0; y < source.height; y += 1) {
+      for (let x = 0; x < source.width; x += 1) {
+        const sourceOffset = source.width * y + x << 2;
+        if (source.data[sourceOffset + 3] === 0) continue;
+        const targetOffset = width * y + x << 2;
+        merged.data[targetOffset] = 217;
+        merged.data[targetOffset + 1] = 70;
+        merged.data[targetOffset + 2] = 239;
+        merged.data[targetOffset + 3] = 255;
+      }
+    }
+  };
+  if (current && merged !== current) merge(current);
+  merge(next);
+  return merged;
+}
+function downscaleDiffMaskToFit(image, maxDimension) {
+  if (image.width <= maxDimension && image.height <= maxDimension) return image;
+  const scale = Math.min(
+    maxDimension / image.width,
+    maxDimension / image.height
+  );
+  const width = Math.max(
+    1,
+    Math.min(maxDimension, Math.round(image.width * scale))
+  );
+  const height = Math.max(
+    1,
+    Math.min(maxDimension, Math.round(image.height * scale))
+  );
+  const output = new import_pngjs.PNG({ width, height });
+  for (let y = 0; y < height; y += 1) {
+    const sourceY0 = Math.floor(y * image.height / height);
+    const sourceY1 = Math.max(
+      sourceY0 + 1,
+      Math.ceil((y + 1) * image.height / height)
+    );
+    for (let x = 0; x < width; x += 1) {
+      const sourceX0 = Math.floor(x * image.width / width);
+      const sourceX1 = Math.max(
+        sourceX0 + 1,
+        Math.ceil((x + 1) * image.width / width)
+      );
+      let changed = false;
+      for (let sourceY = sourceY0; sourceY < sourceY1 && !changed; sourceY += 1) {
+        for (let sourceX = sourceX0; sourceX < sourceX1; sourceX += 1) {
+          const sourceOffset = image.width * sourceY + sourceX << 2;
+          if (image.data[sourceOffset + 3] !== 0) {
+            changed = true;
+            break;
+          }
+        }
+      }
+      if (!changed) continue;
+      const outputOffset = width * y + x << 2;
+      output.data[outputOffset] = 217;
+      output.data[outputOffset + 1] = 70;
+      output.data[outputOffset + 2] = 239;
+      output.data[outputOffset + 3] = 255;
+    }
+  }
+  return output;
+}
+function createVrtStabilityAccumulator(options) {
+  const threshold = options.threshold ?? DEFAULT_VRT_PIXEL_THRESHOLD;
+  const compareOptions = {
+    threshold,
+    ignore: options.ignore ?? [],
+    layout: options.layout
+  };
+  let baseline = null;
+  let cumulativeDiff = null;
+  let runs = 0;
+  let retriedCaptures = 0;
+  const comparisons = [];
+  return {
+    addCapture(capture) {
+      runs += 1;
+      if (capture.retried === true) retriedCaptures += 1;
+      if (!baseline) {
+        baseline = decodeCapture(capture);
+        const scaleX = baseline.width / compareOptions.layout.width;
+        const scaleY = baseline.height / compareOptions.layout.height;
+        for (const region of compareOptions.ignore) {
+          maskRegion(baseline, {
+            x: region.x * scaleX,
+            y: region.y * scaleY,
+            w: region.w * scaleX,
+            h: region.h * scaleY
+          });
+        }
+        return;
+      }
+      const result = compareCaptureToBaseline(
+        baseline,
+        capture,
+        runs,
+        compareOptions
+      );
+      comparisons.push(result.comparison);
+      if (result.comparison.diffPixels > 0) {
+        cumulativeDiff = mergeDiffImage(cumulativeDiff, result.diff);
+      }
+    },
+    get captureCount() {
+      return runs;
+    },
+    summarize() {
+      if (!baseline || runs < 2) {
+        throw new Error(
+          "VRT stability verification requires at least two captures."
+        );
+      }
+      const changed = comparisons.filter(
+        (comparison) => comparison.diffPixels > 0
+      );
+      const mergedDiff = cumulativeDiff;
+      const outputDiff = mergedDiff ? downscaleDiffMaskToFit(mergedDiff, MAX_STABILITY_DIFF_DIMENSION_PX) : null;
+      return {
+        status: changed.length === 0 ? "stable" : "unstable",
+        vrtStable: changed.length === 0,
+        runs,
+        retriedCaptures,
+        threshold,
+        ignoreRegions: compareOptions.ignore.length,
+        changedRuns: changed.length,
+        maxDiffPixels: Math.max(
+          0,
+          ...comparisons.map((item) => item.diffPixels)
+        ),
+        maxDiffRatio: Math.max(0, ...comparisons.map((item) => item.diffRatio)),
+        diffBounds: comparisons.reduce(
+          (bounds, comparison) => unionBounds(bounds, comparison.diffBounds),
+          null
+        ),
+        cumulativeDiff: outputDiff && mergedDiff ? {
+          pngBase64: import_pngjs.PNG.sync.write(outputDiff).toString("base64"),
+          width: outputDiff.width,
+          height: outputDiff.height,
+          sourceWidth: mergedDiff.width,
+          sourceHeight: mergedDiff.height
+        } : null,
+        comparisons
+      };
+    }
+  };
+}
+
 // ../canvas-mcp/tools.ts
 function textResult2(text) {
   return { content: [{ type: "text", text }] };
@@ -45052,12 +45627,12 @@ async function normalizeCanvasSlug(input, workspaceRoot) {
   const value = input.trim().replace(/\\/g, "/").replace(/\/+$/, "").replace(/\/[^/]*\.canvas\.tsx$/i, "");
   if (!value.includes("/")) return value;
   const canvasesDir = resolveCanvasesDirSync(workspaceRoot);
-  const absoluteCanvasesDir = path54.isAbsolute(canvasesDir) ? canvasesDir : path54.join(workspaceRoot, canvasesDir);
-  const candidates = path54.isAbsolute(value) ? [value] : [path54.join(workspaceRoot, value), path54.join(absoluteCanvasesDir, value)];
+  const absoluteCanvasesDir = path55.isAbsolute(canvasesDir) ? canvasesDir : path55.join(workspaceRoot, canvasesDir);
+  const candidates = path55.isAbsolute(value) ? [value] : [path55.join(workspaceRoot, value), path55.join(absoluteCanvasesDir, value)];
   for (const candidate of candidates) {
     const dir = await resolveCanvasDirPath(candidate);
     if (!dir) continue;
-    const relative3 = path54.relative(absoluteCanvasesDir, dir).replace(/\\/g, "/");
+    const relative3 = path55.relative(absoluteCanvasesDir, dir).replace(/\\/g, "/");
     return relative3 && !relative3.startsWith("..") ? relative3 : value;
   }
   return value;
@@ -45793,6 +46368,152 @@ function registerTools(server, context) {
       signal: extra.signal
     })
   );
+  const stabilityErrorResult = (code, message) => errorResult9(`canvas_verify_vrt failed [${code}]: ${message}`);
+  server.tool(
+    "canvas_verify_vrt",
+    "Check that a VRT-tracked storyboard renders identically across fresh mounts so its baseline won't flake in CI. Args: canvas_slug (folder name, or root-relative path when the name isn't unique), storyboard (export name carrying a literal `vrt` prop; `skip: true` is rejected), runs (2\u201310, default 3). Compares each run to run 1 under the visual-review matcher, threshold, and ignore masks. Returns `vrt_stable`; when false, also changed-pixel bounds and a diff-mask image. Call after adding or changing `vrt`; fix the nondeterministic input and rerun. Read-only. Fails fast with capacity_exceeded; typed errors are not retryable.",
+    {
+      canvas_slug: screenshotSchema.canvas_slug,
+      storyboard: z24.string().describe("Storyboard export name carrying the literal `vrt` prop."),
+      runs: z24.number().int().min(2).max(10).default(3).describe("Number of captures to compare. Defaults to 3.")
+    },
+    async ({ canvas_slug, storyboard, runs }, extra) => {
+      if (!context.canvasStoryboardStability)
+        return unsupportedEnvironmentResult("canvasStoryboardStability");
+      try {
+        const slug = await normalizeCanvasSlug(
+          canvas_slug,
+          context.workspaceRoot
+        );
+        const target = await resolveTestedStoryboard({
+          workspaceRoot: context.workspaceRoot,
+          canvasesDir: context.canvasesDir,
+          canvasSlug: slug,
+          storyboard
+        });
+        if (context.canvasDevserver && !context.canvasStoryboardStability.managesDevserver) {
+          try {
+            await context.canvasDevserver.start();
+          } catch (startError) {
+            return errorResult9(
+              `canvas_verify_vrt could not start the canvas devserver: ${startError instanceof Error ? startError.message : String(startError)}`
+            );
+          }
+        }
+        const accumulator = createVrtStabilityAccumulator({
+          threshold: target.vrt.threshold,
+          ignore: target.vrt.ignore,
+          layout: target.layout
+        });
+        let comparisonError;
+        const result = await context.canvasStoryboardStability.captureRuns(
+          {
+            canvasSlug: target.canvasSlug,
+            canvasFile: target.canvasFile,
+            storyboard: target.storyboardId,
+            runs
+          },
+          {
+            timeoutMs: 12e4,
+            signal: extra.signal,
+            onCapture: (capture) => {
+              if (comparisonError) return;
+              try {
+                accumulator.addCapture(capture);
+              } catch (error) {
+                comparisonError = error;
+              }
+            }
+          }
+        );
+        if (comparisonError) {
+          return stabilityErrorResult(
+            "compare_failed",
+            comparisonError instanceof Error ? comparisonError.message : String(comparisonError)
+          );
+        }
+        if (result.kind === "error") {
+          return stabilityErrorResult(
+            result.code,
+            `${result.message}${result.availableStoryboards && result.availableStoryboards.length > 0 ? ` Available storyboards in the current canvas: ${result.availableStoryboards.join(", ")}.` : ""}`
+          );
+        }
+        if (result.runs !== runs || accumulator.captureCount !== runs) {
+          return stabilityErrorResult(
+            "capture_incomplete",
+            `requested ${runs} fresh captures but received ${accumulator.captureCount}.`
+          );
+        }
+        let summary;
+        try {
+          summary = accumulator.summarize();
+        } catch (error) {
+          return stabilityErrorResult(
+            "compare_failed",
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+        const diagnosis = summary.status === "stable" ? `All ${runs} isolated renders are equivalent under the storyboard's VRT threshold and ignore masks.` : `${summary.changedRuns} of ${runs - 1} comparisons changed under the storyboard's VRT policy; the largest changed ${summary.maxDiffPixels} pixels (${(summary.maxDiffRatio * 100).toFixed(4)}%).`;
+        const content = [];
+        if (summary.cumulativeDiff) {
+          content.push({
+            type: "image",
+            data: summary.cumulativeDiff.pngBase64,
+            mimeType: "image/png"
+          });
+        }
+        content.push({
+          type: "text",
+          text: JSON.stringify(
+            {
+              canvas_slug: target.canvasSlug,
+              canvas_file: target.canvasFile,
+              storyboard: target.storyboardId,
+              vrt: target.vrt,
+              status: summary.status,
+              vrt_stable: summary.vrtStable,
+              runs: summary.runs,
+              retried_captures: summary.retriedCaptures,
+              threshold_used: summary.threshold,
+              ignore_regions: summary.ignoreRegions,
+              changed_runs: summary.changedRuns,
+              max_diff_pixels: summary.maxDiffPixels,
+              max_diff_ratio: summary.maxDiffRatio,
+              diff_bounds_device_px: summary.diffBounds,
+              cumulative_diff_image: summary.cumulativeDiff ? {
+                width: summary.cumulativeDiff.width,
+                height: summary.cumulativeDiff.height,
+                source_width: summary.cumulativeDiff.sourceWidth,
+                source_height: summary.cumulativeDiff.sourceHeight,
+                meaning: "Transparent pixels were stable; fuchsia pixels changed in at least one comparison to run 1. Large masks are area-resampled to fit within 1990px without dropping thin differences."
+              } : null,
+              comparisons: summary.comparisons.map((comparison) => ({
+                run: comparison.run,
+                baseline_run: comparison.baselineRun,
+                diff_pixels: comparison.diffPixels,
+                diff_ratio: comparison.diffRatio,
+                diff_bounds_device_px: comparison.diffBounds,
+                dimensions: comparison.dimensions,
+                ...comparison.dimensionChange ? { dimension_change: comparison.dimensionChange } : {}
+              })),
+              diagnosis,
+              next_action: summary.status === "unstable" ? "Inspect the changed region and the storyboard's component dependency graph for nondeterministic render inputs. Replace them with fixed props, fixtures, or seeded inputs, then rerun." : "No deterministic-source change is needed for this storyboard under its current VRT policy."
+            },
+            null,
+            2
+          )
+        });
+        return { content };
+      } catch (error) {
+        if (error instanceof StoryboardStabilityTargetError) {
+          return stabilityErrorResult(error.code, error.message);
+        }
+        return errorResult9(
+          `canvas_verify_vrt failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
   server.tool(
     "canvas_share",
     // The implementation lives in `tempo-client/electron/src/main/adapters/
@@ -45979,26 +46700,20 @@ function buildBackends(runtime, toolsets, workspace) {
 }
 
 // src/version.ts
-var CLI_VERSION = "0.0.105";
+var CLI_VERSION = "0.0.106";
 
 // src/canvas-hooks.ts
-var import_pngjs3 = __toESM(require_png(), 1);
-import path60 from "path";
+var import_pngjs4 = __toESM(require_png(), 1);
+import path61 from "path";
 import { stat as stat10 } from "fs/promises";
 import { gzipSync } from "zlib";
 import { anyApi as anyApi9 } from "convex/server";
 
 // ../canvas-capture-headless/src/capture.ts
-var import_pngjs = __toESM(require_png(), 1);
+var import_pngjs2 = __toESM(require_png(), 1);
 import { createHash as createHash4 } from "crypto";
 
-// ../canvas-capture-headless/src/determinism.ts
-var CHROMIUM_LAUNCH_ARGS = [
-  "--force-color-profile=srgb",
-  "--force-device-scale-factor=2",
-  "--hide-scrollbars",
-  "--disable-lcd-text"
-];
+// ../../modules/frame-pool/capture-determinism.ts
 var FROZEN_EPOCH_MS = Date.UTC(2026, 0, 1, 12, 0, 0);
 function buildFreezeInitScript() {
   return `(() => {
@@ -46018,7 +46733,6 @@ function buildFreezeInitScript() {
   }
   FrozenDate.parse = RealDate.parse;
   FrozenDate.UTC = RealDate.UTC;
-  // eslint-disable-next-line no-global-assign
   Date = FrozenDate;
   globalThis.Date = FrozenDate;
   if (typeof performance !== "undefined") {
@@ -46026,11 +46740,9 @@ function buildFreezeInitScript() {
     const realNow = performance.now.bind(performance);
     performance.now = () => realNow() - origin;
   }
-  // Deterministic Math.random (mulberry32, fixed seed). Reusable capture
-  // pages reset the seed before mounting each storyboard.
   let seed;
   globalThis.__tempoResetCaptureDeterminism = () => {
-    seed = 0x74656d70; // "temp"
+    seed = 0x74656d70;
   };
   globalThis.__tempoResetCaptureDeterminism();
   Math.random = () => {
@@ -46053,6 +46765,14 @@ var FREEZE_MOTION_CSS = `
   caret-color: transparent !important;
 }
 `;
+
+// ../canvas-capture-headless/src/determinism.ts
+var CHROMIUM_LAUNCH_ARGS = [
+  "--force-color-profile=srgb",
+  "--force-device-scale-factor=2",
+  "--hide-scrollbars",
+  "--disable-lcd-text"
+];
 async function runSettleStep(name, work, onStep) {
   const startedAt = Date.now();
   try {
@@ -46143,19 +46863,19 @@ async function settlePage(page, targetSelector, options = {}) {
 // ../canvas-capture-headless/src/ensure-chromium.ts
 import { spawn as spawn7 } from "child_process";
 import { createRequire as createRequire5 } from "module";
-import path55 from "path";
+import path56 from "path";
 var INSTALL_TIMEOUT_MS = 8 * 60 * 1e3;
 function isMissingBrowserError(err) {
   const message = err instanceof Error ? err.message : String(err);
-  return message.includes("Executable doesn't exist") || message.includes("playwright install");
+  return message.includes("Executable doesn't exist") || /playwright install(?!-deps)/.test(message);
 }
 function autoInstallDisabled() {
   return process.env.TEMPO_MCP_NO_AUTO_INSTALL === "1";
 }
 async function installChromium(log, spawnImpl = spawn7) {
   const require3 = createRequire5(import.meta.url);
-  const cliPath = path55.join(
-    path55.dirname(require3.resolve("playwright/package.json")),
+  const cliPath = path56.join(
+    path56.dirname(require3.resolve("playwright/package.json")),
     "cli.js"
   );
   await new Promise((resolve2, reject) => {
@@ -46599,7 +47319,7 @@ function sha256Hex(bytes) {
 function looksBlank(pngBytes) {
   let png;
   try {
-    png = import_pngjs.PNG.sync.read(Buffer.from(pngBytes));
+    png = import_pngjs2.PNG.sync.read(Buffer.from(pngBytes));
   } catch {
     return true;
   }
@@ -46612,6 +47332,86 @@ function looksBlank(pngBytes) {
   }
   return true;
 }
+function isNavigationInterruptedError(message) {
+  return /Execution context was destroyed|most likely because of a navigation|Cannot find context with specified id|[Ff]rame was detached|Navigation interrupted|is interrupted by another navigation|Inspected target navigated or closed|Cannot find object with id|context was destroyed/.test(
+    message
+  );
+}
+function isPageGoneError(message) {
+  return /Target closed|Target page, context or browser has been closed|Page closed|Target crashed/.test(
+    message
+  );
+}
+function isBrowserGoneError(message) {
+  return /Browser has been closed|Browser closed|browser has disconnected|Browser process crashed/.test(
+    message
+  );
+}
+var navigatedErrors = /* @__PURE__ */ new WeakSet();
+function markNavigated(error, navigated) {
+  if (navigated && error !== null && typeof error === "object") {
+    navigatedErrors.add(error);
+  }
+}
+function readNavigatedMark(error) {
+  return error !== null && typeof error === "object" && navigatedErrors.has(error);
+}
+function documentReplaced(start, now, expectedNavigations) {
+  const ownSameDocument = now.sameDocumentIssued - start.sameDocumentIssued;
+  return now.navigationRequests > start.navigationRequests + expectedNavigations || now.frameNavigations > start.frameNavigations + expectedNavigations + ownSameDocument;
+}
+var BOARD_ATTEMPT_LIMIT = 3;
+function decideBoardRetry(attempt, attemptIndex, attemptLimit = BOARD_ATTEMPT_LIMIT) {
+  if (attemptIndex >= attemptLimit - 1) return "accept";
+  if (attempt.status === "render-error") {
+    const message = attempt.error ?? "";
+    if (isBrowserGoneError(message)) return "accept";
+    if (isPageGoneError(message)) return "retry-fresh-worker";
+    if (attempt.navigated || isNavigationInterruptedError(message)) {
+      return "retry";
+    }
+    return "accept";
+  }
+  return attempt.navigated ? "retry" : "accept";
+}
+function navigatedRejectionError(attempts) {
+  return `document reloaded during every attempt (${attempts}); the capture never saw one stable document`;
+}
+function finalizeAcceptedAttempt(attempt, attempts) {
+  const { result } = attempt;
+  if (attempt.navigated && result.status !== "render-error") {
+    return {
+      canvasPath: result.canvasPath,
+      storyboardId: result.storyboardId,
+      status: "render-error",
+      error: navigatedRejectionError(attempts),
+      timings: result.timings
+    };
+  }
+  if (result.status === "render-error" && attempts > 1) {
+    return { ...result, error: `after ${attempts} attempts: ${result.error}` };
+  }
+  return result;
+}
+function reloadStormWindowFor(parallelPages) {
+  return Math.max(8, 4 * Math.max(1, Math.floor(parallelPages)));
+}
+function isReloadStorm(recent, window2) {
+  if (recent.length < window2) return false;
+  return recent.slice(-window2).every(Boolean);
+}
+var CaptureReloadStormError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "CaptureReloadStormError";
+  }
+};
+function describeRetryReason(attempt) {
+  if (attempt.status === "render-error" && isPageGoneError(attempt.error ?? "")) {
+    return "page closed mid-capture";
+  }
+  return "document reloaded mid-capture";
+}
 var DEFAULT_VIEWPORT = { width: 1600, height: 1200 };
 async function startCaptureSession(options) {
   const log = options.log ?? (() => {
@@ -46633,6 +47433,7 @@ async function startCaptureSession(options) {
     os: process.platform,
     browserVersion: browser.version()
   });
+  const browserGoneError = (cause) => new Error(`capture browser is gone; cannot open a fresh page: ${cause}`);
   const createCaptureWorker = async (capture) => {
     const contextStart = Date.now();
     const context = await browser.newContext({
@@ -46653,6 +47454,13 @@ async function startCaptureSession(options) {
       contextMs: Date.now() - contextStart,
       contextClaimed: false,
       hasNavigated: false,
+      counters: {
+        navigationRequests: 0,
+        frameNavigations: 0,
+        sameDocumentIssued: 0
+      },
+      documentsLoaded: 0,
+      navigationsInFlight: 0,
       async dispose() {
         await page.close().catch(() => {
         });
@@ -46660,9 +47468,64 @@ async function startCaptureSession(options) {
         });
       }
     };
+    const isMainFrameNavigation = (request) => {
+      try {
+        return request.isNavigationRequest() && request.frame() === page.mainFrame();
+      } catch {
+        return false;
+      }
+    };
+    page.on("request", (request) => {
+      if (!isMainFrameNavigation(request)) return;
+      if (request.redirectedFrom()) return;
+      worker.counters.navigationRequests += 1;
+      worker.navigationsInFlight += 1;
+    });
+    page.on("requestfailed", (request) => {
+      if (!isMainFrameNavigation(request)) return;
+      worker.navigationsInFlight = Math.max(0, worker.navigationsInFlight - 1);
+    });
+    page.on("framenavigated", (frame) => {
+      if (frame === page.mainFrame()) worker.counters.frameNavigations += 1;
+    });
+    page.on("domcontentloaded", () => {
+      worker.documentsLoaded += 1;
+      worker.navigationsInFlight = 0;
+      if (worker.hasNavigated) {
+        page.addStyleTag({ content: FREEZE_MOTION_CSS }).catch(() => {
+        });
+      }
+    });
     options.timing?.recordBoard("context", worker.contextMs);
     return worker;
   };
+  const sleep6 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+  const awaitDocumentQuiet = async (worker, timeoutMs) => {
+    const quietMs = 500;
+    const deadline = Date.now() + Math.min(timeoutMs, 1e4);
+    const settleLoad = async () => {
+      while (worker.navigationsInFlight > 0 && Date.now() < deadline) {
+        await sleep6(50);
+      }
+      await worker.page.waitForLoadState("load", {
+        timeout: Math.max(1, deadline - Date.now())
+      }).catch(() => {
+      });
+    };
+    await settleLoad();
+    let requests = worker.counters.navigationRequests;
+    let quietSince = Date.now();
+    while (Date.now() < deadline) {
+      await sleep6(100);
+      if (worker.counters.navigationRequests !== requests || worker.navigationsInFlight > 0) {
+        requests = worker.counters.navigationRequests;
+        quietSince = Date.now();
+        await settleLoad();
+      } else if (Date.now() - quietSince >= quietMs) {
+        return;
+      }
+    }
+  };
   const withSettledStoryboard = async (target, capture, timings, work, reusableWorker) => {
     const renderId = storyboardRenderId(
       target.hostCanvasPath,
@@ -46676,6 +47539,9 @@ async function startCaptureSession(options) {
       timings.contextMs = worker.contextMs;
       worker.contextClaimed = true;
     }
+    const countersAtStart = { ...worker.counters };
+    const expectedNavigations = worker.hasNavigated ? 0 : 1;
+    const navigatedSinceStart = () => documentReplaced(countersAtStart, worker.counters, expectedNavigations);
     try {
       const navStart = Date.now();
       try {
@@ -46692,6 +47558,7 @@ async function startCaptureSession(options) {
               history.replaceState(null, "", url);
               window.dispatchEvent(new PopStateEvent("popstate"));
             }, idleUrl.toString());
+            worker.counters.sameDocumentIssued += 1;
             await page.waitForSelector(worker.currentSelector, {
               state: "detached",
               timeout: capture.settleTimeoutMs ?? options.settleTimeoutMs ?? 3e4
@@ -46708,6 +47575,7 @@ async function startCaptureSession(options) {
             },
             { url: targetUrl, nextSelector: selector }
           );
+          worker.counters.sameDocumentIssued += 1;
         }
         worker.currentSelector = selector;
       } finally {
@@ -46798,12 +47666,16 @@ async function startCaptureSession(options) {
         profile.longTaskCount,
         "count"
       );
-      return await work(page, selector);
+      const value = await work(page, selector);
+      return { value, navigated: navigatedSinceStart() };
+    } catch (error) {
+      markNavigated(error, navigatedSinceStart());
+      throw error;
     } finally {
       if (ownsWorker) await worker.dispose();
     }
   };
-  const captureStoryboardArtifacts = async (request) => {
+  const captureStoryboardArtifactsOnce = async (request) => {
     const artifacts = request.artifacts ?? ["png"];
     const timings = { contextMs: 0, navigateMs: 0, settleMs: 0 };
     return withSettledStoryboard(
@@ -46817,7 +47689,7 @@ async function startCaptureSession(options) {
           const pngBytes = new Uint8Array(
             await page.locator(selector).screenshot({ type: "png", animations: "disabled" })
           );
-          const decoded = import_pngjs.PNG.sync.read(Buffer.from(pngBytes));
+          const decoded = import_pngjs2.PNG.sync.read(Buffer.from(pngBytes));
           result.png = {
             pngBytes,
             width: decoded.width,
@@ -46857,6 +47729,31 @@ async function startCaptureSession(options) {
       }
     );
   };
+  const captureStoryboardArtifacts = async (request) => {
+    const key = `${request.hostCanvasPath}#${request.storyboardId}`;
+    for (let attemptIndex = 0; ; attemptIndex += 1) {
+      const lastAttempt = attemptIndex >= BOARD_ATTEMPT_LIMIT - 1;
+      const attempts = attemptIndex + 1;
+      let outcome;
+      try {
+        outcome = await captureStoryboardArtifactsOnce(request);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!browser.isConnected()) throw browserGoneError(message);
+        const retryable = !isBrowserGoneError(message) && (readNavigatedMark(error) || isNavigationInterruptedError(message) || isPageGoneError(message));
+        if (lastAttempt || !retryable) throw error;
+        log(
+          `[capture] ${key}: ${message.split("\n")[0]} (attempt ${attempts}/${BOARD_ATTEMPT_LIMIT}) \u2014 re-capturing`
+        );
+        continue;
+      }
+      if (!outcome.navigated) return outcome.value;
+      if (lastAttempt) throw new Error(navigatedRejectionError(attempts));
+      log(
+        `[capture] ${key}: document reloaded mid-capture (attempt ${attempts}/${BOARD_ATTEMPT_LIMIT}) \u2014 re-capturing`
+      );
+    }
+  };
   const captureOne = async (board, worker) => {
     const timings = {
       contextMs: 0,
@@ -46865,7 +47762,7 @@ async function startCaptureSession(options) {
       screenshotMs: 0
     };
     try {
-      return await withSettledStoryboard(
+      const { value, navigated } = await withSettledStoryboard(
         {
           hostCanvasPath: board.hostCanvasPath,
           storyboardId: board.storyboardId,
@@ -46903,14 +47800,21 @@ async function startCaptureSession(options) {
         },
         worker
       );
+      return { result: value, status: value.status, navigated };
     } catch (error) {
-      return {
+      const result = {
         canvasPath: board.canvasPath,
         storyboardId: board.storyboardId,
         status: "render-error",
         error: error instanceof Error ? error.message : String(error),
         timings
       };
+      return {
+        result,
+        status: result.status,
+        error: result.error,
+        navigated: readNavigatedMark(error)
+      };
     }
   };
   return {
@@ -46919,33 +47823,90 @@ async function startCaptureSession(options) {
     captureBoards: async (boards, captureOptions) => {
       if (boards.length === 0) return [];
       const label = captureOptions?.label ?? "capture";
+      const settleTimeoutMs = options.settleTimeoutMs ?? 3e4;
       const results = new Array(boards.length);
+      const workerCount = Math.max(1, Math.min(parallelPages, boards.length));
+      const stormWindow = reloadStormWindowFor(workerCount);
+      const recentReloadRetries = [];
+      let reloadRetriesTotal = 0;
+      let aborted = false;
       let nextIndex = 0;
       let completed = 0;
-      const workers = Array.from(
-        { length: Math.max(1, Math.min(parallelPages, boards.length)) },
-        async () => {
-          let worker = await createCaptureWorker({});
+      const workers = Array.from({ length: workerCount }, async () => {
+        let worker = await createCaptureWorker({});
+        const replaceWorker = async () => {
+          await worker.dispose();
+          if (!browser.isConnected()) {
+            throw browserGoneError("browser disconnected");
+          }
           try {
-            for (; ; ) {
-              const index = nextIndex;
-              nextIndex += 1;
-              if (index >= boards.length) return;
-              results[index] = await captureOne(boards[index], worker);
-              completed += 1;
-              if (completed % 10 === 0 || completed === boards.length) {
-                log(`${label}: ${completed}/${boards.length}`);
+            worker = await createCaptureWorker({});
+          } catch (error) {
+            throw browserGoneError(
+              error instanceof Error ? error.message : String(error)
+            );
+          }
+        };
+        try {
+          for (; ; ) {
+            if (aborted) return;
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= boards.length) return;
+            const board = boards[index];
+            const key = `${board.canvasPath}#${board.storyboardId}`;
+            let result;
+            let reloadRetries = 0;
+            for (let attemptIndex = 0; ; attemptIndex += 1) {
+              const attempt = await captureOne(board, worker);
+              const decision = decideBoardRetry(attempt, attemptIndex);
+              if (decision === "accept") {
+                result = finalizeAcceptedAttempt(attempt, attemptIndex + 1);
+                if (attemptIndex > 0) {
+                  options.timing?.recordBoard(
+                    "capture.retries",
+                    attemptIndex,
+                    "count"
+                  );
+                }
+                break;
               }
-              if (results[index].status === "render-error") {
-                await worker.dispose();
-                worker = await createCaptureWorker({});
+              const reason = describeRetryReason(attempt);
+              if (reason === "document reloaded mid-capture")
+                reloadRetries += 1;
+              log(
+                `${label}: ${key}: ${reason} (attempt ${attemptIndex + 1}/${BOARD_ATTEMPT_LIMIT}) \u2014 re-capturing`
+              );
+              if (decision === "retry-fresh-worker") {
+                await replaceWorker();
+              } else {
+                await awaitDocumentQuiet(worker, settleTimeoutMs);
               }
             }
-          } finally {
-            await worker.dispose();
+            results[index] = result;
+            completed += 1;
+            if (completed % 10 === 0 || completed === boards.length) {
+              log(`${label}: ${completed}/${boards.length}`);
+            }
+            reloadRetriesTotal += reloadRetries;
+            recentReloadRetries.push(reloadRetries > 0);
+            if (recentReloadRetries.length > stormWindow) {
+              recentReloadRetries.shift();
+            }
+            if (isReloadStorm(recentReloadRetries, stormWindow)) {
+              aborted = true;
+              throw new CaptureReloadStormError(
+                `capture aborted: the devserver reloaded during the last ${stormWindow} storyboards in a row (${reloadRetriesTotal} re-captures so far) \u2014 it is re-optimizing or restarting continuously; see the "devserver:" lines above`
+              );
+            }
+            if (result.status === "render-error") {
+              await replaceWorker();
+            }
           }
+        } finally {
+          await worker.dispose();
         }
-      );
+      });
       await Promise.all(workers);
       return results;
     },
@@ -46973,7 +47934,7 @@ async function startCaptureSession(options) {
 }
 
 // ../canvas-capture-headless/src/composite.ts
-var import_pngjs2 = __toESM(require_png(), 1);
+var import_pngjs3 = __toESM(require_png(), 1);
 var DEFAULT_PADDING = 24;
 function normalizeCompositePadding(value, contentWidth, contentHeight) {
   if (value == null) return DEFAULT_PADDING;
@@ -47003,7 +47964,7 @@ function compositeStoryboardPngs(images, options = {}) {
       throw new Error("Composite image inputs must have finite positions");
     }
     return {
-      png: import_pngjs2.PNG.sync.read(Buffer.from(image.pngBytes)),
+      png: import_pngjs3.PNG.sync.read(Buffer.from(image.pngBytes)),
       x: Math.round(image.x * scale),
       y: Math.round(image.y * scale)
     };
@@ -47027,7 +47988,7 @@ function compositeStoryboardPngs(images, options = {}) {
   );
   const width = contentWidth + padding * 2;
   const height = contentHeight + padding * 2;
-  const output = new import_pngjs2.PNG({ width, height });
+  const output = new import_pngjs3.PNG({ width, height });
   if (options.background) {
     const { r, g, b: b2 } = options.background;
     const a = Math.round((options.background.a ?? 1) * 255);
@@ -47066,17 +48027,17 @@ function compositeStoryboardPngs(images, options = {}) {
     }
   }
   return {
-    pngBytes: new Uint8Array(import_pngjs2.PNG.sync.write(output)),
+    pngBytes: new Uint8Array(import_pngjs3.PNG.sync.write(output)),
     width,
     height
   };
 }
 
 // ../canvas-capture-headless/src/devserver.ts
-import { readFile as readFile24 } from "fs/promises";
-import path56 from "path";
+import { readFile as readFile25 } from "fs/promises";
+import path57 from "path";
 async function readTempoDevserverConfig(tempoConfigPath) {
-  const config = JSON.parse(await readFile24(tempoConfigPath, "utf-8"));
+  const config = JSON.parse(await readFile25(tempoConfigPath, "utf-8"));
   if (!config.scripts?.install || !config.scripts?.start) {
     throw new Error(
       `tempo.config.json at ${tempoConfigPath} must declare scripts.install and scripts.start`
@@ -47092,9 +48053,9 @@ async function readTempoDevserverConfig(tempoConfigPath) {
   };
 }
 function resolveTempoDir(options) {
-  if (options.tempoConfigPath) return path56.dirname(options.tempoConfigPath);
+  if (options.tempoConfigPath) return path57.dirname(options.tempoConfigPath);
   if (options.tempoDir) return options.tempoDir;
-  if (options.repoRoot) return path56.join(options.repoRoot, "tempo");
+  if (options.repoRoot) return path57.join(options.repoRoot, "tempo");
   throw new Error(
     "startDevserverSession needs one of tempoDir, repoRoot, or tempoConfigPath"
   );
@@ -47130,11 +48091,30 @@ async function awaitCanvasRegistration(options) {
     await new Promise((resolve2) => setTimeout(resolve2, retryDelayMs));
   }
 }
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function cleanDevserverLine(line) {
+  return line.replace(ANSI_RE, "").trim();
+}
+function createDevserverLineSplitter() {
+  let remainder = "";
+  return {
+    push(chunk) {
+      const parts = (remainder + chunk).split(/\r?\n/);
+      remainder = parts.pop() ?? "";
+      return parts.map(cleanDevserverLine).filter((line) => line.length > 0);
+    },
+    flush() {
+      const tail = cleanDevserverLine(remainder);
+      remainder = "";
+      return tail.length > 0 ? [tail] : [];
+    }
+  };
+}
 async function startDevserverSession(options) {
   const log = options.log ?? (() => {
   });
   const tempoDir = resolveTempoDir(options);
-  const tempoConfigPath = options.tempoConfigPath ?? path56.join(tempoDir, "tempo.config.json");
+  const tempoConfigPath = options.tempoConfigPath ?? path57.join(tempoDir, "tempo.config.json");
   const config = await readTempoDevserverConfig(tempoConfigPath);
   const hostCanvasPaths = options.hostCanvasPaths ?? [];
   const devServer = new TempoDevServer({
@@ -47143,18 +48123,36 @@ async function startDevserverSession(options) {
     scripts: config.scripts
   });
   await devServer.initialize();
-  const projectRoot = path56.dirname(tempoDir);
+  const projectRoot = path57.dirname(tempoDir);
   for (const hostCanvasPath of hostCanvasPaths) {
     await devServer.ensureCanvasRegistered(
-      path56.join(projectRoot, hostCanvasPath)
+      path57.join(projectRoot, hostCanvasPath)
     );
   }
   const handle = await devServer.startDevServer();
+  const onOutput = options.onOutput;
+  const outputLines = onOutput ? createDevserverLineSplitter() : null;
+  const forwardOutput = (lines) => {
+    if (!onOutput) return;
+    for (const line of lines) {
+      try {
+        onOutput(line);
+      } catch (error) {
+        log(
+          `devserver output listener threw: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  };
+  if (outputLines) {
+    handle.onOutput((data) => forwardOutput(outputLines.push(String(data))));
+  }
   const ready = await handle.waitUntilReady(options.readyTimeoutMs ?? 12e4);
   if (!ready.ok || !ready.url) {
     await handle.stop().catch(() => {
     });
     await devServer.dispose();
+    forwardOutput(outputLines?.flush() ?? []);
     throw new Error(
       `tempobook devserver failed to become ready: ${ready.message ?? (ready.timedOut ? "timeout" : "unknown")}`
     );
@@ -47164,12 +48162,14 @@ async function startDevserverSession(options) {
   log(`devserver ready at ${hostUrl}`);
   const registerCanvas = async (hostCanvasPath) => {
     await devServer.ensureCanvasRegistered(
-      path56.join(projectRoot, hostCanvasPath)
+      path57.join(projectRoot, hostCanvasPath)
     );
     await awaitCanvasRegistration({
       origin,
       hostCanvasPath,
-      reRegister: () => devServer.ensureCanvasRegistered(path56.join(projectRoot, hostCanvasPath)),
+      reRegister: () => devServer.ensureCanvasRegistered(
+        path57.join(projectRoot, hostCanvasPath)
+      ),
       log
     });
   };
@@ -47177,7 +48177,9 @@ async function startDevserverSession(options) {
     await awaitCanvasRegistration({
       origin,
       hostCanvasPath,
-      reRegister: () => devServer.ensureCanvasRegistered(path56.join(projectRoot, hostCanvasPath)),
+      reRegister: () => devServer.ensureCanvasRegistered(
+        path57.join(projectRoot, hostCanvasPath)
+      ),
       log
     });
   }
@@ -47191,26 +48193,27 @@ async function startDevserverSession(options) {
       await handle.stop().catch(() => {
       });
       await devServer.dispose();
+      forwardOutput(outputLines?.flush() ?? []);
     }
   };
 }
 
 // ../canvas-capture-headless/src/enumerate.ts
-import { readFile as readFile25 } from "fs/promises";
-import path57 from "path";
+import { readFile as readFile26 } from "fs/promises";
+import path58 from "path";
 function toPosixPath7(value) {
-  return value.split(path57.sep).join("/");
+  return value.split(path58.sep).join("/");
 }
 async function enumerateCanvasStoryboards(options) {
-  const pagesDir = options.pagesDir ?? path57.join(options.tempoDir, "designs");
-  const projectRoot = path57.dirname(options.tempoDir);
+  const pagesDir = options.pagesDir ?? path58.join(options.tempoDir, "designs");
+  const projectRoot = path58.dirname(options.tempoDir);
   const canvasFiles = await scanCanvasFiles(pagesDir);
   const storyboards = [];
   const structuralErrors = [];
   const vrtConfigErrors = [];
   let totalStoryboards = 0;
   for (const filePath of canvasFiles) {
-    const source = await readFile25(filePath, "utf-8");
+    const source = await readFile26(filePath, "utf-8");
     const parsed = parseCanvasFile(filePath, source);
     const structural = parsed.errors.filter(
       (error) => error.kind === "structural"
@@ -47238,9 +48241,9 @@ async function enumerateCanvasStoryboards(options) {
       continue;
     }
     const canvasPath = toPosixPath7(
-      path57.relative(options.tempoDir, path57.dirname(filePath))
+      path58.relative(options.tempoDir, path58.dirname(filePath))
     );
-    const hostCanvasPath = toPosixPath7(path57.relative(projectRoot, filePath));
+    const hostCanvasPath = toPosixPath7(path58.relative(projectRoot, filePath));
     for (const storyboard of parsed.storyboards) {
       totalStoryboards += 1;
       if (storyboard.kind !== "component") continue;
@@ -47288,7 +48291,7 @@ function describeStyleStarvation(assessment) {
 import { createHash as createHash5 } from "crypto";
 import fs6 from "fs/promises";
 import os3 from "os";
-import path58 from "path";
+import path59 from "path";
 
 // ../workspaces/git-worktree/non-interactive-git.ts
 var NON_INTERACTIVE_GIT_CONFIG = [
@@ -47409,7 +48412,7 @@ async function checkBranchOnRemote(repoPath, branch) {
 
 // ../workspaces/git-worktree/canvas-scan-cache.ts
 import fs7 from "fs/promises";
-import path59 from "path";
+import path60 from "path";
 var DEFAULT_CONCURRENCY = 6;
 var DEFAULT_MAX_AGE_MS = 5 * 6e4;
 var Semaphore = class {
@@ -47435,15 +48438,15 @@ var sharedSemaphore = new Semaphore(DEFAULT_CONCURRENCY);
 
 // src/canvas-hooks.ts
 var MAX_MCP_SCREENSHOT_DIMENSION_PX = 1990;
-function toPosix(value) {
-  return value.split(path60.sep).join("/");
+function toPosix2(value) {
+  return value.split(path61.sep).join("/");
 }
 function normalizeSlug(input) {
   return input.trim().replace(/\\/g, "/").replace(/\/+$/, "").replace(/\/[^/]*\.canvas\.tsx$/i, "");
 }
 async function isCanvasFolder(dir) {
   try {
-    return (await stat10(path60.join(dir, "index.canvas.tsx"))).isFile();
+    return (await stat10(path61.join(dir, "index.canvas.tsx"))).isFile();
   } catch {
     return false;
   }
@@ -47451,18 +48454,18 @@ async function isCanvasFolder(dir) {
 async function resolveCanvas(workspace, canvasSlug) {
   const workspaceRoot = workspace.workspaceRoot;
   const canvasesDir = workspace.canvasesDir;
-  const tempoDir = path60.join(workspaceRoot, "tempo");
+  const tempoDir = path61.join(workspaceRoot, "tempo");
   const enumeration = await enumerateCanvasStoryboards({
     tempoDir,
     pagesDir: canvasesDir
   });
   const byFolder = /* @__PURE__ */ new Map();
   for (const storyboard of enumeration.storyboards) {
-    const folder = path60.dirname(storyboard.filePath);
+    const folder = path61.dirname(storyboard.filePath);
     let canvas = byFolder.get(folder);
     if (!canvas) {
       canvas = {
-        contentPath: toPosix(path60.relative(workspaceRoot, folder)),
+        contentPath: toPosix2(path61.relative(workspaceRoot, folder)),
         hostCanvasPath: storyboard.hostCanvasPath,
         storyboards: []
       };
@@ -47472,15 +48475,15 @@ async function resolveCanvas(workspace, canvasSlug) {
   }
   const slug = normalizeSlug(canvasSlug);
   if (!slug) return { kind: "not_found" };
-  if (slug.includes("/") || path60.isAbsolute(canvasSlug)) {
+  if (slug.includes("/") || path61.isAbsolute(canvasSlug)) {
     for (const [folder, canvas] of byFolder) {
       const candidates = [
-        toPosix(path60.relative(canvasesDir, folder)),
-        toPosix(path60.relative(workspaceRoot, folder)),
-        toPosix(path60.relative(tempoDir, folder))
+        toPosix2(path61.relative(canvasesDir, folder)),
+        toPosix2(path61.relative(workspaceRoot, folder)),
+        toPosix2(path61.relative(tempoDir, folder))
       ];
-      if (path60.isAbsolute(canvasSlug)) {
-        if (path60.resolve(canvasSlug) === folder) {
+      if (path61.isAbsolute(canvasSlug)) {
+        if (path61.resolve(canvasSlug) === folder) {
           return { kind: "ok", canvas };
         }
         continue;
@@ -47489,29 +48492,29 @@ async function resolveCanvas(workspace, canvasSlug) {
     }
   } else {
     const matches = [...byFolder.entries()].filter(
-      ([folder]) => path60.basename(folder) === slug
+      ([folder]) => path61.basename(folder) === slug
     );
     if (matches.length > 1) {
       return {
         kind: "ambiguous",
-        candidates: matches.map(([folder]) => toPosix(path60.relative(canvasesDir, folder))).sort()
+        candidates: matches.map(([folder]) => toPosix2(path61.relative(canvasesDir, folder))).sort()
       };
     }
     if (matches.length === 1) return { kind: "ok", canvas: matches[0][1] };
   }
-  const probeDirs = path60.isAbsolute(canvasSlug) ? [path60.resolve(canvasSlug)] : [
-    path60.join(canvasesDir, slug),
-    path60.join(workspaceRoot, slug),
-    path60.join(tempoDir, slug)
+  const probeDirs = path61.isAbsolute(canvasSlug) ? [path61.resolve(canvasSlug)] : [
+    path61.join(canvasesDir, slug),
+    path61.join(workspaceRoot, slug),
+    path61.join(tempoDir, slug)
   ];
   for (const dir of probeDirs) {
     if (await isCanvasFolder(dir)) {
       return {
         kind: "ok",
         canvas: {
-          contentPath: toPosix(path60.relative(workspaceRoot, dir)),
-          hostCanvasPath: toPosix(
-            path60.relative(workspaceRoot, path60.join(dir, "index.canvas.tsx"))
+          contentPath: toPosix2(path61.relative(workspaceRoot, dir)),
+          hostCanvasPath: toPosix2(
+            path61.relative(workspaceRoot, path61.join(dir, "index.canvas.tsx"))
           ),
           storyboards: []
         }
@@ -47554,7 +48557,7 @@ async function withCaptureSession(workspaceRoot, hostCanvasPath, settleTimeoutMs
   }
 }
 function downscalePngToFit(pngBytes, maxDim) {
-  const png = import_pngjs3.PNG.sync.read(Buffer.from(pngBytes));
+  const png = import_pngjs4.PNG.sync.read(Buffer.from(pngBytes));
   if (png.width <= maxDim && png.height <= maxDim) {
     return {
       pngBase64: Buffer.from(pngBytes).toString("base64"),
@@ -47568,7 +48571,7 @@ function downscalePngToFit(pngBytes, maxDim) {
     maxDim,
     Math.max(1, Math.round(png.height * ratio))
   );
-  const out = new import_pngjs3.PNG({ width: outWidth, height: outHeight });
+  const out = new import_pngjs4.PNG({ width: outWidth, height: outHeight });
   for (let y = 0; y < outHeight; y += 1) {
     const sy0 = Math.floor(y * png.height / outHeight);
     const sy1 = Math.max(
@@ -47602,7 +48605,7 @@ function downscalePngToFit(pngBytes, maxDim) {
       out.data[o + 3] = Math.round(a / count);
     }
   }
-  const bytes = import_pngjs3.PNG.sync.write(out);
+  const bytes = import_pngjs4.PNG.sync.write(out);
   return {
     pngBase64: Buffer.from(bytes).toString("base64"),
     width: outWidth,
@@ -47794,6 +48797,80 @@ function createHeadlessCanvasHooks(options) {
       };
     }
   };
+  const captureStoryboardStability = async (args, captureOptions) => {
+    const resolution = await resolveCanvas(workspace, args.canvasSlug);
+    if (resolution.kind === "ambiguous") {
+      return {
+        kind: "error",
+        code: "ambiguous_canvas_slug",
+        message: ambiguousCanvasSlugMessage(
+          args.canvasSlug,
+          resolution.candidates
+        )
+      };
+    }
+    if (resolution.kind === "not_found") {
+      return {
+        kind: "error",
+        code: "canvas_not_open",
+        message: `No canvas matching "${args.canvasSlug}" exists under ${workspace.canvasesDir}. Pass the canvas's folder name, or its path under the canvases root.`
+      };
+    }
+    const canvas = resolution.canvas;
+    const target = canvas.storyboards.find(
+      (storyboard) => storyboard.storyboardId === args.storyboard
+    );
+    if (!target) {
+      return {
+        kind: "error",
+        code: "storyboard_not_found",
+        message: `Storyboard "${args.storyboard}" is not an export of canvas "${canvas.contentPath}".`,
+        availableStoryboards: canvas.storyboards.map(
+          (storyboard) => storyboard.storyboardId
+        )
+      };
+    }
+    try {
+      const capturedRuns = await withCaptureSession(
+        workspace.workspaceRoot,
+        canvas.hostCanvasPath,
+        captureOptions?.timeoutMs,
+        async (session) => {
+          let streamedRuns = 0;
+          for (let run = 0; run < args.runs; run += 1) {
+            if (captureOptions?.signal?.aborted) {
+              throw captureOptions.signal.reason ?? new Error("Capture aborted");
+            }
+            const png = await session.captureStoryboard({
+              hostCanvasPath: canvas.hostCanvasPath,
+              storyboardId: target.storyboardId,
+              width: target.layout.width,
+              height: target.layout.height
+            });
+            if (looksBlank(png.pngBytes)) {
+              throw new Error(
+                `Storyboard "${target.storyboardId}" rendered an empty frame on run ${run + 1}/${args.runs}.`
+              );
+            }
+            await captureOptions?.onCapture?.({
+              pngBase64: Buffer.from(png.pngBytes).toString("base64"),
+              width: png.width,
+              height: png.height
+            });
+            streamedRuns += 1;
+          }
+          return streamedRuns;
+        }
+      );
+      return { kind: "ok", runs: capturedRuns };
+    } catch (error) {
+      return {
+        kind: "error",
+        code: "capture_threw",
+        message: isMissingPlaywright(error) ? PLAYWRIGHT_INSTALL_HINT : `Headless VRT stability capture failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  };
   const createShareLink = async (args) => {
     const orgProjectId = options.getOrgProjectId();
     if (!orgProjectId) {
@@ -48012,6 +49089,10 @@ function createHeadlessCanvasHooks(options) {
       // canvas_screenshot tool must not try to lease one first.
       managesDevserver: true
     },
+    canvasStoryboardStability: {
+      captureRuns: captureStoryboardStability,
+      managesDevserver: true
+    },
     canvasShare: { create: createShareLink }
   };
 }
@@ -48133,4 +49214,4 @@ export {
   runServe,
   scopeParamsFor
 };
-//# sourceMappingURL=serve-E62XRLQQ.js.map
+//# sourceMappingURL=serve-7RSR6WI6.js.map