@skyramp/mcp 0.1.7 → 0.2.0-rc.1

package/node_modules/playwright/lib/mcp/browser/tools/domAnalyzer.js

@@ -0,0 +1,261 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var domAnalyzer_exports = {};
+__export(domAnalyzer_exports, {
+  default: () => domAnalyzer_default
+});
+module.exports = __toCommonJS(domAnalyzer_exports);
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("./tool");
+var import_crawler = require("../../../dom-analyzer/crawler");
+var import_blueprint = require("../../../dom-analyzer/blueprint");
+var import_serialization = require("../../../dom-analyzer/serialization");
+function hashStorageState(path) {
+  if (!path)
+    return null;
+  try {
+    const contents = fs.readFileSync(path, "utf-8");
+    return crypto.createHash("sha256").update(contents).digest("hex").slice(0, 16);
+  } catch {
+    const pathHash = crypto.createHash("sha256").update(path).digest("hex").slice(0, 16);
+    return `unreadable:${pathHash}`;
+  }
+}
+function cacheKey(entryUrl, storageStateHash, probeButtons) {
+  return `${entryUrl}::${storageStateHash ?? "no-auth"}::${probeButtons}`;
+}
+function humanDuration(ms) {
+  if (ms < 6e4)
+    return `${Math.round(ms / 1e3)}s`;
+  return `${Math.round(ms / 6e4)}m`;
+}
+const sitemapBuild = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_sitemap_build",
+    title: "Build Sitemap (graph of PageBlueprints)",
+    description: [
+      "Crawl an application starting from a URL and build a Sitemap \u2014 a graph of PageBlueprints (one per URL)",
+      "connected by navigation edges. The Sitemap is cached in the session.",
+      "",
+      "Call once at the start of a session. Subsequent calls within the TTL (~30 minutes) reuse the cached",
+      "Sitemap unless `refresh: true` is passed. Use `browser_sitemap_query` to read already-crawled pages",
+      "rather than re-calling this tool.",
+      "",
+      "Depth defaults to 5, maxPages to 50 (the real bound in practice).",
+      "",
+      '\u26A0\uFE0F SAFETY: By default, `probeButtons: "immutable-only"` skips destructive-looking buttons',
+      "(Delete / Submit / Place Order / etc.) and buttons inside forms to prevent side effects during",
+      'crawling. Use `probeButtons: "all"` only against dev / staging environments \u2014 it will click every',
+      "unique button, which can submit forms, create records, send notifications, or mutate server state."
+    ].join("\n"),
+    inputSchema: import_mcpBundle.z.object({
+      url: import_mcpBundle.z.string().describe("Entry URL to start crawling from"),
+      depth: import_mcpBundle.z.number().optional().default(5).describe("Max crawl depth (default: 5)"),
+      maxPages: import_mcpBundle.z.number().optional().default(50).describe("Max pages to visit (default: 50)"),
+      sameOriginOnly: import_mcpBundle.z.boolean().optional().default(true).describe("Only follow same-origin links (default: true)"),
+      probeButtons: import_mcpBundle.z.enum(["immutable-only", "all", "none"]).optional().default("immutable-only").describe('Button-probing safety mode. Default: immutable-only (safe; skips destructive-verb buttons and buttons inside forms). Use "all" only against dev/staging \u2014 probes every button. "none" disables button probing entirely.'),
+      playwrightStoragePath: import_mcpBundle.z.string().optional().describe("Path to a Playwright storageState.json file \u2014 cookies, localStorage, sessionStorage per origin. Use this to crawl apps behind a login."),
+      refresh: import_mcpBundle.z.boolean().optional().default(false).describe("Force a full re-crawl, bypassing the cache")
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const { url, depth, maxPages, sameOriginOnly, probeButtons, playwrightStoragePath, refresh } = params;
+    const normalizedUrl = (0, import_serialization.normalizeUrl)(url);
+    const storageStateHash = hashStorageState(playwrightStoragePath);
+    const probeMode = probeButtons;
+    const key = cacheKey(normalizedUrl, storageStateHash, probeMode);
+    const cached = context.sitemapCache.get(key);
+    if (cached && !refresh) {
+      const age = Date.now() - new Date(cached.sitemap.cachedAt).getTime();
+      if (age < import_serialization.CRAWL_TTL_MS) {
+        const pageCount2 = Object.keys(cached.sitemap.pages).length;
+        response.addTextResult(
+          `Reusing cached Sitemap from ${humanDuration(age)} ago.
+Entry: ${cached.sitemap.entryUrl}
+Pages: ${pageCount2}
+Edges: ${cached.sitemap.edges.length}
+Storage state: ${storageStateHash ? `auth hash ${storageStateHash}` : "none"}
+Probe mode: ${probeMode}
+
+Use browser_sitemap_query to read any page. Pass refresh=true to recrawl.`
+        );
+        return;
+      }
+    }
+    let sitemap;
+    if (depth > 0) {
+      sitemap = await (0, import_crawler.crawl)(url, {
+        depth,
+        maxPages,
+        sameOriginOnly,
+        probeButtons: probeMode,
+        playwrightStoragePath
+      });
+    } else {
+      sitemap = await (0, import_crawler.crawlSinglePage)(url, { playwrightStoragePath });
+    }
+    context.sitemapCache.set(key, { sitemap, storageStateHash, probeButtonsMode: probeMode });
+    const pageCount = Object.keys(sitemap.pages).length;
+    const pageList = Object.keys(sitemap.pages).map((u) => {
+      const bp = sitemap.pages[u];
+      const elCount = bp.sections.reduce((sum, s) => sum + s.elements.length + s.repeatingElements.length, 0);
+      return `  - ${u} (${elCount} elements across ${bp.sections.length} sections)`;
+    }).join("\n");
+    response.addTextResult(
+      `Sitemap built for ${sitemap.entryUrl}
+Pages: ${pageCount}
+Edges: ${sitemap.edges.length}
+Storage state: ${storageStateHash ? `auth hash ${storageStateHash}` : "none"}
+Probe mode: ${probeMode}
+
+Pages:
+${pageList}
+
+Use browser_sitemap_query to read page blueprints, edges, or derived views (mapJson, outline).`
+    );
+  }
+});
+const sitemapQuery = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_sitemap_query",
+    title: "Query the cached Sitemap",
+    description: [
+      "Query the Sitemap cached by browser_sitemap_build. Use this instead of re-calling sitemap_build.",
+      "",
+      "Modes:",
+      "  page     \u2014 returns the full canonical PageBlueprint for the given URL",
+      "             (sections with enrichment, logical names, XPaths)",
+      "  edges    \u2014 returns navigation edges originating from the given URL",
+      "  mapJson  \u2014 returns the derived flat logicalName \u2192 xpath map for the URL",
+      "  outline  \u2014 returns the derived textual section-to-element hierarchy for the URL",
+      "  overview \u2014 (when url is omitted) returns page list + edge list summary"
+    ].join("\n"),
+    inputSchema: import_mcpBundle.z.object({
+      type: import_mcpBundle.z.enum(["page", "edges", "mapJson", "outline"]).optional().describe("Query mode. Omit with url to get overview."),
+      url: import_mcpBundle.z.string().optional().describe("Page URL to query. Omit to get overview across all pages.")
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    if (context.sitemapCache.size === 0) {
+      response.addError("No Sitemap available. Run browser_sitemap_build first.");
+      return;
+    }
+    const latest = [...context.sitemapCache.values()].sort(
+      (a, b) => new Date(b.sitemap.cachedAt).getTime() - new Date(a.sitemap.cachedAt).getTime()
+    )[0];
+    const sitemap = latest.sitemap;
+    const { type, url } = params;
+    if (!url || !type) {
+      const overview = {
+        schemaVersion: sitemap.schemaVersion,
+        entryUrl: sitemap.entryUrl,
+        cachedAt: sitemap.cachedAt,
+        pages: Object.keys(sitemap.pages).map((u) => ({
+          url: u,
+          sections: sitemap.pages[u].sections.length,
+          elements: sitemap.pages[u].sections.reduce(
+            (s, sec) => s + sec.elements.length + sec.repeatingElements.length,
+            0
+          ),
+          pageHash: sitemap.pages[u].pageHash
+        })),
+        edges: sitemap.edges
+      };
+      response.addTextResult(JSON.stringify(overview, null, 2));
+      return;
+    }
+    const normalizedQueryUrl = (0, import_serialization.normalizeUrl)(url);
+    const blueprint2 = sitemap.pages[normalizedQueryUrl];
+    if (!blueprint2) {
+      response.addError(
+        `Page not found in Sitemap: ${normalizedQueryUrl}. Available pages: ${Object.keys(sitemap.pages).join(", ")}`
+      );
+      return;
+    }
+    if (type === "page") {
+      response.addTextResult(JSON.stringify(blueprint2, null, 2));
+      return;
+    }
+    if (type === "edges") {
+      const edges = sitemap.edges.filter((e) => e.from === normalizedQueryUrl);
+      response.addTextResult(JSON.stringify({ url: normalizedQueryUrl, edges }, null, 2));
+      return;
+    }
+    if (type === "mapJson") {
+      response.addTextResult(JSON.stringify((0, import_blueprint.buildMap)(blueprint2), null, 2));
+      return;
+    }
+    if (type === "outline") {
+      response.addTextResult((0, import_blueprint.buildOutline)(blueprint2));
+      return;
+    }
+  }
+});
+const blueprint = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_blueprint",
+    title: "Build PageBlueprint for the current page",
+    description: [
+      "Build a PageBlueprint for the currently loaded page. Returns the canonical `sections` tree",
+      "containing singular elements and repeating-element shapes, each carrying enrichment fields",
+      "(mutability, widgetType, framePath, shadowRoot, stableId, testId).",
+      "",
+      "Call this only when the DOM has changed since the last known-good blueprint \u2014 e.g. after a",
+      "modal opens, a form submits, a filter changes a list, or any mutable action. For pure navigation",
+      "to an already-crawled URL, reuse the Sitemap cache via browser_sitemap_query.",
+      "",
+      "Logical names are stable \u2014 use them in generated test code. Refs (from browser_snapshot) are",
+      "ephemeral \u2014 use them only for dispatching the next interaction, never in generated code."
+    ].join("\n"),
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab, _params, response) => {
+    try {
+      const bp = await (0, import_blueprint.buildPageBlueprint)(tab.page);
+      response.addTextResult(JSON.stringify(bp, null, 2));
+    } catch (err) {
+      if (err instanceof import_blueprint.BlueprintInvariantError) {
+        response.addError(
+          `Blueprint invariant violated: ${err.message}. This is a builder bug; please file an issue with the URL of the page that triggered it.`
+        );
+        return;
+      }
+      throw err;
+    }
+  }
+});
+var domAnalyzer_default = [sitemapBuild, sitemapQuery, blueprint];

package/node_modules/playwright/lib/mcp/browser/tools/keyboard.js

@@ -29,9 +29,9 @@ const pressKey = (0, import_tool.defineTabTool)({
   schema: {
     name: "browser_press_key",
     title: "Press a key",
-    description: "Press a key on the keyboard",
+    description: "Press a single key on the globally-focused element. This is a FALLBACK tool \u2014 prefer higher-level tools whenever possible: browser_click for buttons and links, browser_type for text entry, browser_type with submit: true for form submission (bundles the fill and the Enter into one recorded action). Only use browser_press_key when no semantic alternative exists: arrow-key navigation in an already-open listbox or combobox, Escape to close a modal that has no visible close button, Tab to shift focus between fields, or an app-specific keyboard shortcut the user actually relies on (e.g. Ctrl+K to open a command palette).",
     inputSchema: import_mcpBundle.z.object({
-      key: import_mcpBundle.z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`")
+      key: import_mcpBundle.z.string().describe('Key name or character, e.g. "ArrowDown", "Enter", "Escape", "a". Supports modifier combinations like "Control+a" or "Meta+v".')
     }),
     type: "input"
   },
@@ -77,7 +77,7 @@ const type = (0, import_tool.defineTabTool)({
   schema: {
     name: "browser_type",
     title: "Type text",
-    description: "Type text into an editable element. Auto-focuses and replaces existing content. NEVER call browser_click on the field first \u2014 clicking before typing injects extra network requests that corrupt the trace.",
+    description: "Type text into an editable element. Auto-focuses and replaces existing content. NEVER call browser_click on the field first \u2014 clicking before typing injects extra network requests that corrupt the trace. When recording a UI trace for capture-act-capture, capture browser_blueprint before and after to derive form-state assertions from the textChanges delta.",
     inputSchema: typeSchema,
     type: "input"
   },

package/node_modules/playwright/lib/mcp/browser/tools/pageBlueprint.js

@@ -0,0 +1,129 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pageBlueprint_exports = {};
+__export(pageBlueprint_exports, {
+  default: () => pageBlueprint_default
+});
+module.exports = __toCommonJS(pageBlueprint_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("./tool");
+var import_blueprint = require("../../../dom-analyzer/blueprint");
+var import_blueprintDiff = require("../../../dom-analyzer/blueprintDiff");
+const blueprint = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_blueprint",
+    title: "Build PageBlueprint for the current page",
+    description: [
+      "Build a PageBlueprint for the currently loaded page.",
+      "",
+      "RETURN SHAPE \u2014 two cases:",
+      "",
+      "1. First call at a URL (or after the cache has evicted the entry):",
+      '   {"isFullCapture": true, "pageHash": "...", "blueprint": {...full PageBlueprint...}}',
+      "",
+      "2. Subsequent call at the same URL:",
+      '   {"isFullCapture": false, "pageHash": "...", "previousPageHash": "...", "delta": {...BlueprintDelta...}}',
+      "   The delta is computed automatically against your most recent blueprint at this URL.",
+      "   Empty arrays in delta (elementsAdded/Removed/textChanges) mean the action did not change observable DOM.",
+      "",
+      "CAPTURE-ACT-CAPTURE: capture once before your action, perform the action, capture again \u2014 the second",
+      "response IS the diff. You only need browser_blueprint_diff when comparing across different URLs.",
+      "",
+      "Logical names are stable \u2014 use them in generated test code. Refs (from browser_snapshot) are",
+      "ephemeral \u2014 never use them in generated code."
+    ].join("\n"),
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab, _params, response) => {
+    try {
+      const current = await (0, import_blueprint.buildPageBlueprint)(tab.page);
+      const url = current.url;
+      const previous = tab.blueprintCache.get(url);
+      if (!previous) {
+        tab.blueprintCache.put(url, current);
+        response.addTextResult(JSON.stringify({
+          isFullCapture: true,
+          pageHash: current.pageHash,
+          blueprint: current
+        }, null, 2));
+        return;
+      }
+      const delta = (0, import_blueprintDiff.diffBlueprints)(previous, current);
+      tab.blueprintCache.put(url, current);
+      response.addTextResult(JSON.stringify({
+        isFullCapture: false,
+        pageHash: current.pageHash,
+        previousPageHash: previous.pageHash,
+        delta
+      }, null, 2));
+    } catch (err) {
+      if (err instanceof import_blueprint.BlueprintInvariantError) {
+        response.addError(
+          `Blueprint invariant violated: ${err.message}. This is a builder bug; please file an issue with the URL of the page that triggered it.`
+        );
+        return;
+      }
+      throw err;
+    }
+  }
+});
+const PageBlueprintLooseSchema = import_mcpBundle.z.object({
+  schemaVersion: import_mcpBundle.z.literal(1).describe("Always 1 for the current PageBlueprint format. Copy from the captured blueprint."),
+  url: import_mcpBundle.z.string().describe("Page URL the blueprint was captured from. Copy from the captured blueprint."),
+  capturedAt: import_mcpBundle.z.string().describe("ISO-8601 UTC timestamp of capture. Copy from the captured blueprint."),
+  pageHash: import_mcpBundle.z.string().describe("Cheap hash of the page structure for staleness detection. Copy from the captured blueprint."),
+  sections: import_mcpBundle.z.array(import_mcpBundle.z.any()).describe("The blueprint's sections array \u2014 full structural data. Copy from the captured blueprint without modification.")
+});
+const blueprintDiff = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_blueprint_diff",
+    title: "Diff two PageBlueprints",
+    description: [
+      "Compute a structured delta between two PageBlueprints.",
+      "",
+      "In most cases you do NOT need this tool \u2014 browser_blueprint already returns",
+      "the delta against the previous capture at the same URL automatically.",
+      "",
+      "Use this tool only when:",
+      "  \u2022 Comparing blueprints across DIFFERENT URLs (e.g. before/after a navigation)",
+      "    \u2014 diffing across URLs is supported and produces a delta with urlChange populated.",
+      "  \u2022 Reconstructing a delta from blueprints captured outside the current cache window.",
+      "",
+      "Both blueprints must be from the same MCP session \u2014 the tool cannot verify this.",
+      "Judgment about which facts become assertions lives in the NL \u2192 Trace prompt,",
+      "not in this tool."
+    ].join("\n"),
+    inputSchema: import_mcpBundle.z.object({
+      before: PageBlueprintLooseSchema.describe("PageBlueprint captured BEFORE the action (e.g. before a click that opens a dialog). Pass the full blueprint object returned by an earlier browser_blueprint call."),
+      after: PageBlueprintLooseSchema.describe("PageBlueprint captured AFTER the action. Same shape as `before`. The tool computes the structured delta \u2014 what was added, removed, or changed.")
+    }),
+    type: "readOnly"
+  },
+  handle: async (_context, params, response) => {
+    const delta = (0, import_blueprintDiff.diffBlueprints)(
+      params.before,
+      params.after
+    );
+    response.addTextResult(JSON.stringify(delta, null, 2));
+  }
+});
+var pageBlueprint_default = [blueprint, blueprintDiff];

package/node_modules/playwright/lib/mcp/browser/tools/pageBlueprint.test.js

@@ -0,0 +1,137 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var import_blueprint = require("../../../dom-analyzer/blueprint");
+var import_blueprintCache = require("../../../dom-analyzer/blueprintCache");
+var import_pageBlueprint = __toESM(require("./pageBlueprint"));
+import_vitest.vi.mock("../../../dom-analyzer/blueprint", async () => {
+  const actual = await import_vitest.vi.importActual("../../../dom-analyzer/blueprint");
+  return {
+    ...actual,
+    buildPageBlueprint: import_vitest.vi.fn()
+  };
+});
+const blueprintTool = import_pageBlueprint.default.find((t) => t.schema.name === "browser_blueprint");
+function fakeBp(url, pageHash, sections = []) {
+  return {
+    schemaVersion: 1,
+    url,
+    capturedAt: "2026-05-16T00:00:00.000Z",
+    pageHash,
+    sections
+  };
+}
+function mkTab(url) {
+  return {
+    page: { url: () => url },
+    blueprintCache: new import_blueprintCache.BlueprintCache(5),
+    modalStates: () => []
+  };
+}
+function mkContext(tab) {
+  return {
+    ensureTab: async () => tab
+  };
+}
+function mkResponse() {
+  const calls = [];
+  return {
+    addTextResult: (s) => calls.push(s),
+    addError: (s) => calls.push("ERR:" + s),
+    setIncludeSnapshot: () => {
+    },
+    addCode: (_s) => {
+    },
+    _calls: calls
+  };
+}
+(0, import_vitest.beforeEach)(() => {
+  import_vitest.vi.clearAllMocks();
+});
+(0, import_vitest.describe)("browser_blueprint cache", () => {
+  (0, import_vitest.it)("first call at a URL returns isFullCapture: true with the blueprint", async () => {
+    const tab = mkTab("http://a/orders/1");
+    const ctx = mkContext(tab);
+    const bp = fakeBp("http://a/orders/1", "h1");
+    import_blueprint.buildPageBlueprint.mockResolvedValueOnce(bp);
+    const resp = mkResponse();
+    await blueprintTool.handle(ctx, {}, resp);
+    (0, import_vitest.expect)(resp._calls).toHaveLength(1);
+    const out = JSON.parse(resp._calls[0]);
+    (0, import_vitest.expect)(out.isFullCapture).toBe(true);
+    (0, import_vitest.expect)(out.pageHash).toBe("h1");
+    (0, import_vitest.expect)(out.blueprint).toEqual(bp);
+  });
+  (0, import_vitest.it)("second call at same URL returns isFullCapture: false with a delta", async () => {
+    const tab = mkTab("http://a/orders/1");
+    const ctx = mkContext(tab);
+    const bp1 = fakeBp("http://a/orders/1", "h1");
+    const bp2 = fakeBp("http://a/orders/1", "h2");
+    import_blueprint.buildPageBlueprint.mockResolvedValueOnce(bp1).mockResolvedValueOnce(bp2);
+    await blueprintTool.handle(ctx, {}, mkResponse());
+    const r2 = mkResponse();
+    await blueprintTool.handle(ctx, {}, r2);
+    const out2 = JSON.parse(r2._calls[0]);
+    (0, import_vitest.expect)(out2.isFullCapture).toBe(false);
+    (0, import_vitest.expect)(out2.pageHash).toBe("h2");
+    (0, import_vitest.expect)(out2.previousPageHash).toBe("h1");
+    (0, import_vitest.expect)(out2.delta).toMatchObject({
+      pageHashChange: { before: "h1", after: "h2" },
+      hasStructuralChange: import_vitest.expect.any(Boolean),
+      elementsAdded: import_vitest.expect.any(Array),
+      elementsRemoved: import_vitest.expect.any(Array),
+      textChanges: import_vitest.expect.any(Array)
+    });
+  });
+  (0, import_vitest.it)("updates stored entry so third call diffs against second", async () => {
+    const tab = mkTab("http://a/orders/1");
+    const ctx = mkContext(tab);
+    const bp1 = fakeBp("http://a/orders/1", "h1");
+    const bp2 = fakeBp("http://a/orders/1", "h2");
+    const bp3 = fakeBp("http://a/orders/1", "h3");
+    import_blueprint.buildPageBlueprint.mockResolvedValueOnce(bp1).mockResolvedValueOnce(bp2).mockResolvedValueOnce(bp3);
+    await blueprintTool.handle(ctx, {}, mkResponse());
+    await blueprintTool.handle(ctx, {}, mkResponse());
+    const r3 = mkResponse();
+    await blueprintTool.handle(ctx, {}, r3);
+    const out3 = JSON.parse(r3._calls[0]);
+    (0, import_vitest.expect)(out3.isFullCapture).toBe(false);
+    (0, import_vitest.expect)(out3.previousPageHash).toBe("h2");
+    (0, import_vitest.expect)(out3.pageHash).toBe("h3");
+  });
+  (0, import_vitest.it)("different URL gets its own full capture", async () => {
+    const tab = mkTab("http://a/orders/1");
+    const ctx = mkContext(tab);
+    const bp1 = fakeBp("http://a/orders/1", "h1");
+    const bp2 = fakeBp("http://a/orders/2", "g1");
+    import_blueprint.buildPageBlueprint.mockResolvedValueOnce(bp1).mockResolvedValueOnce(bp2);
+    await blueprintTool.handle(ctx, {}, mkResponse());
+    tab.page.url = () => "http://a/orders/2";
+    const r2 = mkResponse();
+    await blueprintTool.handle(ctx, {}, r2);
+    const out2 = JSON.parse(r2._calls[0]);
+    (0, import_vitest.expect)(out2.isFullCapture).toBe(true);
+    (0, import_vitest.expect)(out2.blueprint).toEqual(bp2);
+  });
+});