@tempo-ai/mcp 0.0.107-staging.2 → 0.0.108-staging.1

package/dist/bin.js

@@ -2,7 +2,7 @@
 import { createRequire as __tempoCreateRequire } from 'node:module'; const require = __tempoCreateRequire(import.meta.url);
 import {
   run
-} from "./chunk-DIHGIFJY.js";
+} from "./chunk-ZCZBV667.js";
 import "./chunk-KFUOQZBJ.js";
 
 // src/bin.ts

package/dist/{call-E2GGFNEQ.js → call-ZMSUWCQM.js}

@@ -8,7 +8,7 @@ import {
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 async function connectAggregate(options) {
-  const { createTempoAggregate } = await import("./serve-T6OLREL7.js");
+  const { createTempoAggregate } = await import("./serve-GFI2SFGS.js");
   const handle = await createTempoAggregate(options);
   const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
   const client = new Client({ name: "tempo-mcp-cli", version: "0" });
@@ -127,4 +127,4 @@ export {
   runCall,
   runTools
 };
-//# sourceMappingURL=call-E2GGFNEQ.js.map
+//# sourceMappingURL=call-ZMSUWCQM.js.map

package/dist/{chunk-DIHGIFJY.js → chunk-ZCZBV667.js}

@@ -157,7 +157,7 @@ async function run(argv) {
         process.stderr.write(USAGE);
         return 1;
       }
-      const { runServe } = await import("./serve-T6OLREL7.js");
+      const { runServe } = await import("./serve-GFI2SFGS.js");
       return await runServe(options);
     }
     switch (subcommand) {
@@ -172,11 +172,11 @@ async function run(argv) {
         return await runToken(rest);
       }
       case "tools": {
-        const { runTools } = await import("./call-E2GGFNEQ.js");
+        const { runTools } = await import("./call-ZMSUWCQM.js");
         return await runTools(rest);
       }
       case "call": {
-        const { runCall } = await import("./call-E2GGFNEQ.js");
+        const { runCall } = await import("./call-ZMSUWCQM.js");
         return await runCall(rest);
       }
       default:
@@ -195,4 +195,4 @@ async function run(argv) {
 export {
   run
 };
-//# sourceMappingURL=chunk-DIHGIFJY.js.map
+//# sourceMappingURL=chunk-ZCZBV667.js.map

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRequire as __tempoCreateRequire } from 'node:module'; const require = __tempoCreateRequire(import.meta.url);
 import {
   run
-} from "./chunk-DIHGIFJY.js";
+} from "./chunk-ZCZBV667.js";
 import "./chunk-KFUOQZBJ.js";
 export {
   run

package/dist/{serve-T6OLREL7.js → serve-GFI2SFGS.js}

@@ -24812,6 +24812,7 @@ function abortableWait(cancelledMessage) {
 import { spawn as spawn2 } from "child_process";
 import path10 from "path";
 var BUNDLED_NODE_BIN_DIR_ENV = "TEMPO_NODE_TOOLCHAIN_BIN_DIR";
+var BUNDLED_NODE_RUNTIME_ENV = "TEMPO_NODE_TOOLCHAIN_RUNTIME";
 function getBundledNodeBinDir() {
   const dir = process.env[BUNDLED_NODE_BIN_DIR_ENV];
   return dir && dir.trim().length > 0 ? dir : null;
@@ -24830,10 +24831,13 @@ function shouldUseBundledNode(args) {
 }
 function applyBundledNodeEnv(env, binDir) {
   if (!binDir) return env;
-  return {
-    ...prependDirToPathEnv(env, binDir),
-    ELECTRON_RUN_AS_NODE: "1"
-  };
+  const next = prependDirToPathEnv(env, binDir);
+  if (env[BUNDLED_NODE_RUNTIME_ENV] === "native") {
+    delete next.ELECTRON_RUN_AS_NODE;
+  } else {
+    next.ELECTRON_RUN_AS_NODE = "1";
+  }
+  return next;
 }
 function prependDirToPathEnv(env, dir) {
   const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path");
@@ -27978,7 +27982,7 @@ async function parcelEventToFileEvent(event, rootInfo) {
 // ../tempo-sdk/package.json
 var package_default = {
   name: "tempo-sdk",
-  version: "0.0.40",
+  version: "0.0.42",
   type: "module",
   description: "Tempo SDK \u2014 Vite, Next.js, and Expo plugins for JSX annotation and shared page/storyboard types",
   repository: {
@@ -46547,9 +46551,66 @@ import path58 from "path";
 import { promisify as promisify4 } from "util";
 
 // ../canvas-capture-headless/src/capture.ts
-var import_pngjs2 = __toESM(require_png(), 1);
 import { createHash as createHash4 } from "crypto";
 
+// ../../modules/iframe-projection/combined/projection-pending.ts
+var PROJECTION_PENDING_ATTRIBUTE = "data-tempo-projection-pending";
+
+// ../../modules/component-render-pool/direct-render.ts
+var DIRECT_RENDER_PARAMS = {
+  canvasPath: "canvasPath",
+  storyboardId: "storyboardId",
+  width: "width",
+  height: "height",
+  intrinsicSize: "intrinsicSize",
+  idle: "tempoCaptureIdle"
+};
+var STORYBOARD_RENDER_ID_ATTRIBUTE = "data-tempo-storyboard-render-id";
+var STORYBOARD_PENDING_SELECTOR = `[${PROJECTION_PENDING_ATTRIBUTE}]`;
+function buildCanvasStoryboardRenderId(canvasPath, storyboardId) {
+  return `canvas:${encodeURIComponent(canvasPath.trim())}#storyboard:${encodeURIComponent(
+    storyboardId.trim()
+  )}`;
+}
+function buildStoryboardRenderSelector(renderId) {
+  return `[${STORYBOARD_RENDER_ID_ATTRIBUTE}=${JSON.stringify(renderId)}]`;
+}
+function buildDirectRenderUrl(hostUrl, target) {
+  const hasWidth = target.width !== void 0;
+  const hasHeight = target.height !== void 0;
+  if (hasWidth !== hasHeight) {
+    throw new Error("Direct render width and height must be provided together");
+  }
+  const url = new URL(hostUrl);
+  url.searchParams.delete(DIRECT_RENDER_PARAMS.idle);
+  url.searchParams.set(DIRECT_RENDER_PARAMS.canvasPath, target.canvasPath);
+  url.searchParams.set(DIRECT_RENDER_PARAMS.storyboardId, target.storyboardId);
+  if (hasWidth && hasHeight) {
+    url.searchParams.set(DIRECT_RENDER_PARAMS.width, String(target.width));
+    url.searchParams.set(DIRECT_RENDER_PARAMS.height, String(target.height));
+  } else {
+    url.searchParams.delete(DIRECT_RENDER_PARAMS.width);
+    url.searchParams.delete(DIRECT_RENDER_PARAMS.height);
+  }
+  if (target.intrinsicSize) {
+    url.searchParams.set(DIRECT_RENDER_PARAMS.intrinsicSize, "1");
+  } else {
+    url.searchParams.delete(DIRECT_RENDER_PARAMS.intrinsicSize);
+  }
+  return url.toString();
+}
+function buildDirectRenderIdleUrl(hostUrl) {
+  const url = new URL(hostUrl);
+  for (const param of Object.values(DIRECT_RENDER_PARAMS)) {
+    url.searchParams.delete(param);
+  }
+  url.searchParams.set(DIRECT_RENDER_PARAMS.idle, "1");
+  return url.toString();
+}
+
+// ../canvas-capture-headless/src/capture.ts
+var import_pngjs2 = __toESM(require_png(), 1);
+
 // ../../modules/frame-pool/capture-determinism.ts
 var FROZEN_EPOCH_MS = Date.UTC(2026, 0, 1, 12, 0, 0);
 function buildFreezeInitScript() {
@@ -46603,100 +46664,240 @@ var FREEZE_MOTION_CSS = `
 }
 `;
 
-// ../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/settle-script.ts
+var SETTLE_STEPS = [
+  "target",
+  "fonts",
+  "suspense",
+  "content-quiet",
+  "paint"
 ];
-async function runSettleStep(name, work, onStep) {
-  const startedAt = Date.now();
-  try {
-    return await work();
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`settle.${name}: ${message}`);
-  } finally {
-    onStep?.(name, Date.now() - startedAt);
-  }
-}
-async function settlePage(page, targetSelector, options = {}) {
-  const quietMs = options.quietMs ?? 300;
-  const timeoutMs = options.timeoutMs ?? 15e3;
-  await runSettleStep(
-    "target",
-    () => page.waitForSelector(targetSelector, {
-      state: "attached",
-      timeout: timeoutMs
-    }),
-    options.onStep
-  );
-  await runSettleStep(
-    "fonts",
-    () => page.waitForFunction(() => document.fonts.status === "loaded", {
-      timeout: timeoutMs
-    }),
-    options.onStep
+var DEFAULT_SETTLE_QUIET_MS = 300;
+var DEFAULT_SETTLE_STEP_TIMEOUT_MS = 15e3;
+var DEFAULT_SETTLE_POLL_MS = 50;
+function buildSettleWaitScript(options) {
+  const quietMs = Math.max(0, Math.round(options.quietMs ?? DEFAULT_SETTLE_QUIET_MS));
+  const stepTimeoutMs = Math.max(
+    1,
+    Math.round(options.stepTimeoutMs ?? DEFAULT_SETTLE_STEP_TIMEOUT_MS)
   );
-  await runSettleStep(
-    "suspense",
-    () => page.waitForFunction(
-      (selector) => {
-        const target = document.querySelector(selector);
-        if (!target) return false;
-        return !target.querySelector("[data-tempo-projection-pending]");
-      },
-      targetSelector,
-      { timeout: timeoutMs }
-    ),
-    options.onStep
+  const quietTimeoutMs = Math.max(
+    1,
+    Math.round(options.quietTimeoutMs ?? stepTimeoutMs)
   );
-  await runSettleStep(
-    "content-quiet",
-    () => page.waitForFunction(
-      ({ selector, quiet }) => {
-        const target = document.querySelector(selector);
+  const pollMs = Math.max(1, Math.round(options.pollMs ?? DEFAULT_SETTLE_POLL_MS));
+  return `
+    (function() {
+      var selector = ${JSON.stringify(options.selector)};
+      var pendingSelector = ${JSON.stringify(options.pendingSelector ?? null)};
+      var quietMs = ${quietMs};
+      var stepTimeoutMs = ${stepTimeoutMs};
+      var quietTimeoutMs = ${quietTimeoutMs};
+      var quietBestEffort = ${options.quietBestEffort === true ? "true" : "false"};
+      var pollMs = ${pollMs};
+      var runPaint = ${options.paint === false ? "false" : "true"};
+      var steps = {};
+      // Cleared when the content-quiet step gives up under best effort.
+      var quiet = true;
+      // Monotonic and immune to the determinism kit's frozen Date.
+      var now = typeof performance !== 'undefined' && performance && typeof performance.now === 'function'
+        ? function() { return performance.now(); }
+        : function() { return Date.now(); };
+
+      function failure(step, message) {
+        return { ok: false, step: step, message: message, steps: steps };
+      }
+
+      // Polls \`check\` until it answers true, or \`budgetMs\` elapses. The
+      // first check runs synchronously so an already-settled step costs no
+      // poll interval. A step run with \`giveUp\` resolves at its budget
+      // instead of failing, recording that the content never held still.
+      function until(step, check, budgetMs, giveUp) {
+        var started = now();
+        return new Promise(function(resolve, reject) {
+          function tick() {
+            var done;
+            try {
+              done = check();
+            } catch (error) {
+              steps[step] = Math.round(now() - started);
+              reject(failure(step, String((error && error.message) || error)));
+              return;
+            }
+            if (done) {
+              steps[step] = Math.round(now() - started);
+              resolve();
+              return;
+            }
+            if (now() - started >= budgetMs) {
+              steps[step] = Math.round(now() - started);
+              if (giveUp) {
+                quiet = false;
+                resolve();
+                return;
+              }
+              reject(failure(step, 'Timeout ' + budgetMs + 'ms exceeded'));
+              return;
+            }
+            setTimeout(tick, pollMs);
+          }
+          tick();
+        });
+      }
+
+      var quietKey = null;
+      var quietSince = 0;
+      // Images that take part in the capture: laid out and not hidden. A
+      // hidden responsive variant never starts native lazy loading and must
+      // not hold the window; a rendered lazy image never starts either,
+      // because a capture does not scroll, so it is asked for eagerly.
+      function renderedImages(target) {
+        var all = Array.prototype.slice.call(target.querySelectorAll('img'));
+        var rendered = [];
+        for (var i = 0; i < all.length; i++) {
+          var img = all[i];
+          if (img.getClientRects().length === 0) continue;
+          var visibility = getComputedStyle(img).visibility;
+          if (visibility === 'hidden' || visibility === 'collapse') continue;
+          rendered.push(img);
+        }
+        return rendered;
+      }
+      function contentQuiet() {
+        var target = document.querySelector(selector);
         if (!target) return false;
-        const images = Array.from(target.querySelectorAll("img"));
-        if (images.some((img) => !img.complete)) return false;
-        const rect = target.getBoundingClientRect();
-        const text = target.innerText ?? "";
-        const key = [
+        var images = renderedImages(target);
+        for (var i = 0; i < images.length; i++) {
+          if (images[i].loading === 'lazy') images[i].loading = 'eager';
+        }
+        for (var j = 0; j < images.length; j++) {
+          if (!images[j].complete) {
+            // Load/error handlers can replace content without moving its
+            // geometry: start a fresh quiet window once they have run.
+            quietKey = null;
+            return false;
+          }
+        }
+        var rect = target.getBoundingClientRect();
+        var text = target.innerText || '';
+        var key = [
           rect.x,
           rect.y,
           rect.width,
           rect.height,
-          target.querySelectorAll("*").length,
+          target.querySelectorAll('*').length,
           text.length,
           images.length
-        ].join(",");
-        const state = window.__tempoVisualReviewQuiet ?? {};
-        window.__tempoVisualReviewQuiet = state;
-        const now = performance.now();
-        if (state.key !== key) {
-          state.key = key;
-          state.since = now;
+        ].join(',');
+        var at = now();
+        if (quietKey !== key) {
+          quietKey = key;
+          quietSince = at;
           return false;
         }
-        return now - state.since >= quiet;
-      },
-      { selector: targetSelector, quiet: quietMs },
-      { timeout: timeoutMs, polling: 50 }
-    ),
-    options.onStep
-  );
-  await runSettleStep(
-    "paint",
-    () => page.evaluate(
-      () => new Promise(
-        (resolve2) => requestAnimationFrame(() => requestAnimationFrame(() => resolve2()))
-      )
-    ),
-    options.onStep
+        return at - quietSince >= quietMs;
+      }
+
+      function paint() {
+        if (!runPaint) return Promise.resolve();
+        var started = now();
+        return new Promise(function(resolve) {
+          requestAnimationFrame(function() {
+            requestAnimationFrame(function() {
+              steps.paint = Math.round(now() - started);
+              resolve();
+            });
+          });
+        });
+      }
+
+      return until('target', function() {
+          return document.querySelector(selector) !== null;
+        }, stepTimeoutMs, false)
+        .then(function() {
+          return until('fonts', function() {
+            var fonts = document.fonts;
+            return !fonts || fonts.status === 'loaded';
+          }, stepTimeoutMs, false);
+        })
+        .then(function() {
+          return until('suspense', function() {
+            if (!pendingSelector) return true;
+            var target = document.querySelector(selector);
+            if (!target) return false;
+            return !target.querySelector(pendingSelector);
+          }, stepTimeoutMs, false);
+        })
+        .then(function() {
+          return until('content-quiet', contentQuiet, quietTimeoutMs, quietBestEffort);
+        })
+        .then(paint)
+        .then(
+          function() {
+            return { ok: true, steps: steps, quiet: quiet };
+          },
+          function(caught) {
+            if (caught && caught.ok === false) return caught;
+            return failure('paint', String((caught && caught.message) || caught));
+          }
+        );
+    })()
+  `;
+}
+
+// ../canvas-capture-headless/src/navigation-errors.ts
+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
   );
 }
 
+// ../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 settlePage(page, targetSelector, options = {}) {
+  const quietMs = options.quietMs ?? 300;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const budgetMs = timeoutMs * SETTLE_STEPS.length;
+  const deadline = Date.now() + budgetMs;
+  let resumes = 0;
+  for (; ; ) {
+    let report;
+    try {
+      report = await page.evaluate(
+        buildSettleWaitScript({
+          selector: targetSelector,
+          pendingSelector: STORYBOARD_PENDING_SELECTOR,
+          quietMs,
+          stepTimeoutMs: Math.max(1, Math.min(timeoutMs, deadline - Date.now()))
+        })
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!isNavigationInterruptedError(message)) throw error;
+      resumes += 1;
+      if (Date.now() >= deadline) {
+        throw new Error(
+          `settle: Timeout ${budgetMs}ms exceeded; the document was replaced ${resumes} times while waiting`
+        );
+      }
+      continue;
+    }
+    for (const step of SETTLE_STEPS) {
+      const ms = report.steps[step];
+      if (ms !== void 0) options.onStep?.(step, ms);
+    }
+    if (!report.ok) {
+      throw new Error(`settle.${report.step}: ${report.message}`);
+    }
+    return;
+  }
+}
+
 // ../canvas-capture-headless/src/ensure-chromium.ts
 import { spawn as spawn7 } from "child_process";
 import { createRequire as createRequire5 } from "module";
@@ -46756,7 +46957,7 @@ async function installChromium(log, spawnImpl = spawn7) {
 }
 
 // ../canvas-capture-headless/src/fingerprint.ts
-var KIT_VERSION = "2";
+var KIT_VERSION = "3";
 var FONTS_BUNDLE_VERSION = "system-1";
 var DEVICE_SCALE_FACTOR = 2;
 function buildEnvFingerprint(input) {
@@ -47143,15 +47344,15 @@ function readRenderProfileInPage(targetCanvasPath) {
 
 // ../canvas-capture-headless/src/capture.ts
 function storyboardRenderId(hostCanvasPath, storyboardId) {
-  return `canvas:${encodeURIComponent(hostCanvasPath.trim())}#storyboard:${encodeURIComponent(storyboardId.trim())}`;
-}
-function buildDirectRenderUrl(hostUrl, target) {
-  const url = new URL(hostUrl);
-  url.searchParams.set("canvasPath", target.hostCanvasPath);
-  url.searchParams.set("storyboardId", target.storyboardId);
-  url.searchParams.set("width", String(target.width));
-  url.searchParams.set("height", String(target.height));
-  return url.toString();
+  return buildCanvasStoryboardRenderId(hostCanvasPath, storyboardId);
+}
+function buildDirectRenderUrl2(hostUrl, target) {
+  return buildDirectRenderUrl(hostUrl, {
+    canvasPath: target.hostCanvasPath,
+    storyboardId: target.storyboardId,
+    width: target.width,
+    height: target.height
+  });
 }
 function sha256Hex(bytes) {
   return createHash4("sha256").update(bytes).digest("hex");
@@ -47172,11 +47373,6 @@ 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
@@ -47371,7 +47567,7 @@ async function startCaptureSession(options) {
       target.hostCanvasPath,
       target.storyboardId
     );
-    const selector = `[data-tempo-storyboard-render-id=${JSON.stringify(renderId)}]`;
+    const selector = buildStoryboardRenderSelector(renderId);
     const ownsWorker = reusableWorker === void 0;
     const worker = reusableWorker ?? await createCaptureWorker(capture);
     const { page } = worker;
@@ -47385,19 +47581,17 @@ async function startCaptureSession(options) {
     try {
       const navStart = Date.now();
       try {
-        const targetUrl = buildDirectRenderUrl(options.hostUrl, target);
+        const targetUrl = buildDirectRenderUrl2(options.hostUrl, target);
         if (!worker.hasNavigated) {
           await page.goto(targetUrl, { waitUntil: "domcontentloaded" });
           await page.addStyleTag({ content: FREEZE_MOTION_CSS });
           worker.hasNavigated = true;
         } else {
           if (worker.currentSelector === selector) {
-            const idleUrl = new URL(options.hostUrl);
-            idleUrl.searchParams.set("tempoCaptureIdle", "1");
             await page.evaluate((url) => {
               history.replaceState(null, "", url);
               window.dispatchEvent(new PopStateEvent("popstate"));
-            }, idleUrl.toString());
+            }, buildDirectRenderIdleUrl(options.hostUrl));
             worker.counters.sameDocumentIssued += 1;
             await page.waitForSelector(worker.currentSelector, {
               state: "detached",
@@ -47408,7 +47602,6 @@ async function startCaptureSession(options) {
             ({ url, nextSelector }) => {
               const captureWindow = window;
               captureWindow.__tempoResetCaptureDeterminism?.();
-              delete captureWindow.__tempoVisualReviewQuiet;
               captureWindow.__tempoCaptureRenderProfile?.begin(nextSelector);
               history.replaceState(null, "", url);
               window.dispatchEvent(new PopStateEvent("popstate"));
@@ -51027,7 +51220,7 @@ function buildBackends(runtime, toolsets, workspace) {
 }
 
 // src/version.ts
-var CLI_VERSION = "0.0.107-staging.2";
+var CLI_VERSION = "0.0.108-staging.1";
 
 // src/canvas-hooks.ts
 var import_pngjs4 = __toESM(require_png(), 1);
@@ -51059,9 +51252,9 @@ function nonInteractiveGitEnv(base = process.env) {
 }
 
 // ../workspaces/git-worktree/worktree.ts
-var GIT_CONFIG = ["core.optionalLocks=false"];
+var GIT_BINARY = ["git", "--no-optional-locks"];
 function simpleGit2(repoPath) {
-  return repoPath ? simpleGit({ baseDir: repoPath, config: [...GIT_CONFIG] }) : simpleGit({ config: [...GIT_CONFIG] });
+  return repoPath ? simpleGit({ baseDir: repoPath, binary: GIT_BINARY }) : simpleGit({ binary: GIT_BINARY });
 }
 async function getRemoteUrl2(repoPath, remoteName = "origin") {
   const git = simpleGit2(repoPath);
@@ -51148,7 +51341,8 @@ async function computeShareStatus(repoPath) {
 async function checkBranchOnRemote(repoPath, branch) {
   const git = simpleGit({
     baseDir: repoPath,
-    config: [...GIT_CONFIG, ...NON_INTERACTIVE_GIT_CONFIG],
+    binary: GIT_BINARY,
+    config: [...NON_INTERACTIVE_GIT_CONFIG],
     timeout: { block: 15e3 }
   }).env(nonInteractiveGitEnv());
   try {
@@ -51963,4 +52157,4 @@ export {
   runServe,
   scopeParamsFor
 };
-//# sourceMappingURL=serve-T6OLREL7.js.map
+//# sourceMappingURL=serve-GFI2SFGS.js.map