@tempo-ai/visual-review 0.0.122 → 0.0.123-staging.2

package/dist/bin.js

@@ -6,7 +6,7 @@ async function main(argv = process.argv.slice(2)) {
   const [command, ...commandArgs] = argv;
   switch (command) {
     case "capture":
-      return await (await import("./cli-K6WGJOVH.js")).main(commandArgs);
+      return await (await import("./cli-KP6UZ2X7.js")).main(commandArgs);
     case "claim":
       return await (await import("./claim-J654JAS6.js")).main(commandArgs);
     case "report":

package/dist/{chunk-LFAVQ3IP.js → chunk-HUMMTEGB.js}

@@ -9,7 +9,7 @@ import {
 import { execFileSync, spawn as spawn6 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir7, mkdtemp as mkdtemp2, rm as rm6, writeFile as writeFile7 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
+import { tmpdir } from "os";
 import path18 from "path";
 
 // ../canvas-capture-headless/src/capture.ts
@@ -4380,12 +4380,6 @@ function getInstalledWatchProvider() {
   return getSlot().provider;
 }
 
-// ../../modules/file-watcher/watcher.ts
-import { lstat as lstat2, realpath, stat as stat2, unlink } from "fs/promises";
-import { createRequire as createRequire2 } from "module";
-import { tmpdir } from "os";
-import { join as join3, relative } from "path";
-
 // ../../modules/file-watcher/ignore.ts
 import picomatch from "picomatch";
 function asSubtreePath(pattern) {
@@ -4433,7 +4427,7 @@ function resolveIgnoreRoots(realRoot, ignorePaths) {
   }
   return out;
 }
-async function scanTree(realRoot, ignorePaths = []) {
+async function scanTree(realRoot, ignorePaths = [], keepEntry = () => true) {
   const ignored = resolveIgnoreRoots(realRoot, ignorePaths);
   const scan = /* @__PURE__ */ new Map();
   const pendingStats = [];
@@ -4450,7 +4444,8 @@ async function scanTree(realRoot, ignorePaths = []) {
     }
     for (const entry of entries) {
       const full = join2(dir, entry.name);
-      if (ignored.has(full)) continue;
+      if (ignored.has(full) || !keepEntry(full)) continue;
+      if (entry.isDirectory() && !keepEntry(`${full}/`)) continue;
       if (entry.isDirectory() && !entry.isSymbolicLink()) {
         scan.set(full, { mtimeMs: 0, size: 0, isDir: true });
         if (depth < MAX_DEPTH) queue.push({ dir: full, depth: depth + 1 });
@@ -4515,7 +4510,136 @@ async function readScanSnapshot(snapshotPath) {
   }
 }
 
+// ../../modules/file-watcher/polling-scans.ts
+function deliver(reader, scan) {
+  reader.delivery = reader.delivery.then(async () => {
+    if (reader.active) await reader.onScan(scan);
+  }).catch((error) => {
+    try {
+      reader.onError(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    } catch {
+    }
+  });
+  return reader.delivery;
+}
+function createPollingScanPool(scan = scanTree) {
+  const scans = /* @__PURE__ */ new Map();
+  let queue = Promise.resolve();
+  async function subscribe(root, ignore, reader) {
+    const exclusions = [
+      ...new Set(
+        ignore.filter(
+          (p) => !splitIgnorePatterns([p]).relativePathFilters.length || p.endsWith("/**") || p.endsWith("/")
+        )
+      )
+    ].sort();
+    const key2 = JSON.stringify([root, exclusions]);
+    let entry = scans.get(key2);
+    if (!entry) {
+      entry = {
+        root,
+        readers: /* @__PURE__ */ new Set(),
+        timer: null,
+        running: null,
+        baseline: null,
+        scanCount: 0,
+        lastDurationMs: 0
+      };
+      scans.set(key2, entry);
+    }
+    const shared = entry;
+    const subscriber = {
+      ...reader,
+      active: true,
+      delivery: Promise.resolve()
+    };
+    shared.readers.add(subscriber);
+    const { nativeIgnorePaths, relativePathFilters } = splitIgnorePatterns(exclusions);
+    const keep = createEventKeepFilter(root, relativePathFilters);
+    function schedule() {
+      if (!shared.readers.size || shared.timer) return;
+      const interval = Math.min(...[...shared.readers].map((r) => r.interval));
+      shared.timer = setTimeout(() => {
+        shared.timer = null;
+        void run().catch(() => {
+        });
+      }, interval);
+    }
+    function run() {
+      if (shared.running) return shared.running;
+      const operation = queue.then(async () => {
+        if (!shared.readers.size) return;
+        const start = performance.now();
+        const snapshot = await scan(root, nativeIgnorePaths, keep);
+        shared.lastDurationMs = performance.now() - start;
+        shared.scanCount++;
+        shared.baseline = snapshot;
+        await Promise.all([...shared.readers].map((r) => deliver(r, snapshot)));
+      });
+      queue = operation.catch(() => {
+      });
+      shared.running = operation.catch((error) => {
+        for (const r of shared.readers) {
+          try {
+            r.onError(
+              error instanceof Error ? error : new Error(String(error))
+            );
+          } catch {
+          }
+        }
+        throw error;
+      }).finally(() => {
+        shared.running = null;
+        schedule();
+      });
+      return shared.running;
+    }
+    try {
+      if (shared.baseline) await deliver(subscriber, shared.baseline);
+      else await run();
+    } catch (error) {
+      subscriber.active = false;
+      shared.readers.delete(subscriber);
+      if (!shared.readers.size) {
+        if (shared.timer) clearTimeout(shared.timer);
+        if (scans.get(key2) === shared) scans.delete(key2);
+      }
+      throw error;
+    }
+    return {
+      async unsubscribe() {
+        subscriber.active = false;
+        shared.readers.delete(subscriber);
+        await subscriber.delivery;
+        if (shared.readers.size) return;
+        if (shared.timer) clearTimeout(shared.timer);
+        shared.timer = null;
+        if (scans.get(key2) === shared) scans.delete(key2);
+        await shared.running?.catch(() => {
+        });
+      }
+    };
+  }
+  return {
+    subscribe,
+    getDiagnostics: () => [...scans.values()].map((s) => ({
+      root: s.root,
+      consumers: s.readers.size,
+      entries: s.baseline?.size ?? 0,
+      scanCount: s.scanCount,
+      lastDurationMs: s.lastDurationMs,
+      scanning: s.running !== null
+    }))
+  };
+}
+var pollingScanPool = createPollingScanPool();
+
 // ../../modules/file-watcher/watcher.ts
+import { lstat as lstat2, realpath, stat as stat2 } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { relative } from "path";
 var DEFAULT_DEBOUNCE_MS = 100;
 var DEFAULT_MAX_BATCH_SIZE = 1e3;
 var DEFAULT_MAX_BUFFERED_EVENTS = 3e4;
@@ -4529,7 +4653,9 @@ var requireModule = createRequire2(
 var nativeWatcherPromise = null;
 function loadNativeWatcher() {
   nativeWatcherPromise ??= Promise.resolve().then(() => {
-    const loaded = requireModule("@parcel/watcher");
+    const loaded = requireModule(
+      "@parcel/watcher"
+    );
     return loaded.default ?? loaded;
   });
   return nativeWatcherPromise;
@@ -4758,25 +4884,20 @@ async function watchWithPolling(rootPath, callback, options) {
     onError = (err) => {
       console.error("[file-watcher] Error:", err.message);
     },
-    autoRecover = false,
     snapshotPath,
     resumeFromSnapshot,
     pollingIntervalMs = DEFAULT_POLLING_INTERVAL_MS
   } = options;
   const rootSymlinkInfo = await resolveRootPath(rootPath);
-  const { nativeIgnorePaths, relativePathFilters } = splitIgnorePatterns(ignore);
+  const { relativePathFilters } = splitIgnorePatterns(ignore);
   const keepEvent = createEventKeepFilter(
     rootSymlinkInfo.realPath,
     relativePathFilters
   );
   const pollingInterval = Math.max(MIN_POLLING_INTERVAL_MS, pollingIntervalMs);
-  const generatedSnapshotPath = join3(
-    tmpdir(),
-    `file-watcher-polling-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`
-  );
-  const effectiveSnapshotPath = resumeFromSnapshot ?? snapshotPath ?? generatedSnapshotPath;
-  const shouldCleanupSnapshot = !snapshotPath && !resumeFromSnapshot;
+  const effectiveSnapshotPath = snapshotPath ?? resumeFromSnapshot;
   let baseline = null;
+  let snapshotDirty = false;
   if (resumeFromSnapshot) {
     baseline = await readScanSnapshot(resumeFromSnapshot);
     if (!baseline) {
@@ -4789,8 +4910,6 @@ async function watchWithPolling(rootPath, callback, options) {
   }
   let eventBuffer = [];
   let debounceTimer = null;
-  let pollTimer = null;
-  let pollInFlight = null;
   let disposed = false;
   function scheduleFlush() {
     if (debounceTimer || disposed) return;
@@ -4817,75 +4936,47 @@ async function watchWithPolling(rootPath, callback, options) {
       scheduleFlush();
     }
   }
-  async function pollOnce() {
-    if (disposed) return;
-    if (pollInFlight) return;
-    pollInFlight = (async () => {
-      try {
-        const scan = await scanTree(
-          rootSymlinkInfo.realPath,
-          nativeIgnorePaths
-        );
+  const scanSubscription = await pollingScanPool.subscribe(
+    rootSymlinkInfo.realPath,
+    ignore,
+    {
+      interval: pollingInterval,
+      onError,
+      async onScan(scan) {
         if (disposed) return;
         const previous = baseline;
         baseline = scan;
-        void writeScanSnapshot(effectiveSnapshotPath, scan).catch(() => {
-        });
-        if (!previous) return;
-        const polledEvents = diffScans(previous, scan).filter(
-          (event) => keepEvent(event.path)
-        );
-        if (disposed || polledEvents.length === 0) return;
+        const changes = previous ? diffScans(previous, scan) : [];
+        snapshotDirty ||= !previous || changes.length > 0;
+        if (effectiveSnapshotPath && snapshotDirty) {
+          await writeScanSnapshot(effectiveSnapshotPath, scan).then(
+            () => {
+              snapshotDirty = false;
+            },
+            () => {
+            }
+          );
+        }
+        if (disposed || !previous) return;
+        const polledEvents = changes.filter((event) => keepEvent(event.path));
+        if (!polledEvents.length) return;
         const remaining = DEFAULT_MAX_BUFFERED_EVENTS - eventBuffer.length;
-        if (remaining <= 0) {
+        if (polledEvents.length > remaining)
           onError(new Error("Event buffer full, dropping events"));
-        } else {
-          eventBuffer.push(...polledEvents.slice(0, remaining));
-          scheduleFlush();
-        }
-      } catch (err) {
-        onError(err instanceof Error ? err : new Error(String(err)));
-        if (autoRecover) {
-          baseline = null;
-        }
-      } finally {
-        pollInFlight = null;
+        eventBuffer.push(...polledEvents.slice(0, Math.max(0, remaining)));
+        scheduleFlush();
       }
-    })();
-    await pollInFlight;
-  }
-  await pollOnce();
-  if (!disposed) {
-    pollTimer = setInterval(() => {
-      pollOnce().catch((err) => {
-        onError(err instanceof Error ? err : new Error(String(err)));
-      });
-    }, pollingInterval);
-  }
+    }
+  );
   return {
     async unsubscribe() {
       disposed = true;
-      if (pollTimer) {
-        clearInterval(pollTimer);
-        pollTimer = null;
-      }
       if (debounceTimer) {
         clearTimeout(debounceTimer);
         debounceTimer = null;
       }
-      if (pollInFlight) {
-        try {
-          await pollInFlight;
-        } catch {
-        }
-      }
+      await scanSubscription.unsubscribe();
       eventBuffer = [];
-      if (shouldCleanupSnapshot) {
-        try {
-          await unlink(effectiveSnapshotPath);
-        } catch {
-        }
-      }
     }
   };
 }
@@ -5001,7 +5092,7 @@ function describeInstallConnectivity(output) {
 // ../tempo-sdk/package.json
 var package_default = {
   name: "tempo-sdk",
-  version: "0.0.51",
+  version: "0.0.52",
   type: "module",
   description: "Tempo SDK \u2014 Vite, Next.js, and Expo plugins for JSX annotation and shared page/storyboard types",
   repository: {
@@ -8329,7 +8420,19 @@ function resolveManagedWatchBackend(platform = process.platform, override = proc
 }
 var WATCH_BACKEND = resolveManagedWatchBackend();
 var MANAGED_WATCH_OPTIONS = {
-  ignore: ["node_modules/**", ".git/**", "dist/**", "build/**", ".next/**"],
+  diagnosticKind: "devserver-managed",
+  ignore: [
+    "node_modules/**",
+    "**/node_modules/**",
+    ".git/**",
+    "**/.git/**",
+    "dist/**",
+    "**/dist/**",
+    "build/**",
+    "**/build/**",
+    ".next/**",
+    "**/.next/**"
+  ],
   debounceMs: 50,
   coalesce: true,
   autoRecover: true,
@@ -9050,6 +9153,7 @@ var TempoDevServer = class _TempoDevServer {
     // @parcel/watcher with recursive watching, batching, coalescing, and
     // auto-recovery, so this path does not need a periodic drift-polling backstop.
     this.managedFileWatchers = [];
+    this.managedWatchVersion = 0;
     this.managedFileWatcherStopPromise = null;
     this.repairDebounceTimer = null;
     // Backoff for self-enqueued drift-correction passes that keep finding the
@@ -10555,13 +10659,15 @@ var TempoDevServer = class _TempoDevServer {
   // add/delete drift.
   async startManagedFileWatchers() {
     if (this.disposed) return;
-    await this.stopManagedFileWatchers();
-    if (this.disposed) return;
+    const stopping = this.stopManagedFileWatchers();
+    const version = this.managedWatchVersion;
+    await stopping;
+    if (this.disposed || version !== this.managedWatchVersion) return;
     try {
       const subscription = await watch(
         this.projectRoot,
         (events) => {
-          if (this.disposed) return;
+          if (this.disposed || version !== this.managedWatchVersion) return;
           if (!events.some((event) => this.isManagedWatcherEvent(event))) {
             return;
           }
@@ -10572,9 +10678,16 @@ var TempoDevServer = class _TempoDevServer {
           // Transport interruption: the coverage gap may have missed a
           // managed-file change. repair() re-derives everything from disk,
           // so one scheduled repair reconciles any drift fully.
-          onInterruption: () => this.scheduleManagedRepair()
+          onInterruption: () => {
+            if (!this.disposed && version === this.managedWatchVersion)
+              this.scheduleManagedRepair();
+          }
         }
       );
+      if (this.disposed || version !== this.managedWatchVersion) {
+        await subscription.unsubscribe();
+        return;
+      }
       this.managedFileWatchers.push(subscription);
     } catch (error) {
       devLog("managed-file-watcher:start_failed", {
@@ -10584,6 +10697,7 @@ var TempoDevServer = class _TempoDevServer {
     }
   }
   async stopManagedFileWatchers() {
+    ++this.managedWatchVersion;
     if (this.managedFileWatcherStopPromise) {
       await this.managedFileWatcherStopPromise;
       return;
@@ -13740,7 +13854,7 @@ function buildBaselineCaptureArgs(input) {
 }
 async function runBaselineCaptureInWorktree(options) {
   const tempParent = await mkdtemp2(
-    path18.join(process.env.RUNNER_TEMP || tmpdir2(), "tempo-vrt-baseline-")
+    path18.join(process.env.RUNNER_TEMP || tmpdir(), "tempo-vrt-baseline-")
   );
   const worktreeRoot = path18.join(tempParent, "repo");
   try {
@@ -14244,4 +14358,4 @@ export {
   buildBaselineCaptureArgs,
   main
 };
-//# sourceMappingURL=chunk-LFAVQ3IP.js.map
+//# sourceMappingURL=chunk-HUMMTEGB.js.map