@agent-scope/cli 1.11.0 → 1.13.0

package/dist/index.cjs

@@ -228,9 +228,9 @@ function createRL() {
   });
 }
 async function ask(rl, question) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     rl.question(question, (answer) => {
-      resolve10(answer.trim());
+      resolve12(answer.trim());
     });
   });
 }
@@ -1547,9 +1547,364 @@ Available: ${available}`
   );
   return cmd;
 }
+var MANIFEST_PATH4 = ".reactscope/manifest.json";
+var DEFAULT_VIEWPORT_WIDTH = 375;
+var DEFAULT_VIEWPORT_HEIGHT = 812;
+var _pool = null;
+async function getPool() {
+  if (_pool === null) {
+    _pool = new render.BrowserPool({
+      size: { browsers: 1, pagesPerBrowser: 1 },
+      viewportWidth: DEFAULT_VIEWPORT_WIDTH,
+      viewportHeight: DEFAULT_VIEWPORT_HEIGHT
+    });
+    await _pool.init();
+  }
+  return _pool;
+}
+async function shutdownPool() {
+  if (_pool !== null) {
+    await _pool.close();
+    _pool = null;
+  }
+}
+function mapNodeType(node) {
+  if (node.type === "forward_ref") return "forwardRef";
+  if (node.type === "host") return "host";
+  const name = node.name;
+  if (name.endsWith(".Provider") || name === "Provider") return "context.provider";
+  if (name.endsWith(".Consumer") || name === "Consumer") return "context.consumer";
+  return node.type;
+}
+function flattenSerializedValue(sv) {
+  if (sv === null || sv === void 0) return null;
+  const v = sv;
+  switch (v.type) {
+    case "null":
+    case "undefined":
+      return null;
+    case "string":
+    case "number":
+    case "boolean":
+      return v.value;
+    case "object": {
+      if (!Array.isArray(v.entries)) return {};
+      const result = {};
+      for (const entry of v.entries) {
+        result[entry.key] = flattenSerializedValue(entry.value);
+      }
+      return result;
+    }
+    case "array": {
+      if (!Array.isArray(v.items)) return [];
+      return v.items.map(flattenSerializedValue);
+    }
+    case "function":
+      return "[Function]";
+    case "symbol":
+      return `[Symbol: ${v.description ?? ""}]`;
+    case "circular":
+      return "[Circular]";
+    case "truncated":
+      return `[Truncated: ${v.preview ?? ""}]`;
+    default:
+      return v.preview ?? null;
+  }
+}
+function flattenHookState(hooks) {
+  const result = {};
+  for (let i = 0; i < hooks.length; i++) {
+    const hook = hooks[i];
+    if (hook === void 0) continue;
+    const key = hook.name !== null && hook.name !== void 0 ? hook.name : `${hook.type}[${i}]`;
+    result[key] = flattenSerializedValue(hook.value);
+  }
+  return result;
+}
+function extractContextNames(contexts) {
+  const names = contexts.map((c) => c.contextName ?? "Unknown").filter((name, idx, arr) => arr.indexOf(name) === idx);
+  return names;
+}
+function anyContextChanged(contexts) {
+  return contexts.some((c) => c.didTriggerRender);
+}
+function convertToInstrumentNode(node, depth = 0) {
+  const contexts = extractContextNames(node.context);
+  const contextChanged = anyContextChanged(node.context);
+  const state = flattenHookState(node.state);
+  const propsFlat = flattenSerializedValue(node.props);
+  const props = propsFlat !== null && typeof propsFlat === "object" && !Array.isArray(propsFlat) ? propsFlat : {};
+  return {
+    component: node.name,
+    type: mapNodeType(node),
+    renderCount: node.renderCount,
+    lastRenderDuration: node.renderDuration,
+    memoized: node.type === "memo",
+    // memoSkipped requires tracking bail-outs across commits — not available from
+    // a single-shot capture. Defaulted to 0.
+    memoSkipped: 0,
+    props,
+    // propsChanged is not tracked in a single-shot capture — would need a diff
+    // between two renders. Defaulted to false.
+    propsChanged: false,
+    state,
+    stateChanged: false,
+    contextChanged,
+    contexts,
+    depth,
+    children: node.children.map((child) => convertToInstrumentNode(child, depth + 1))
+  };
+}
+function filterByContext(node, contextName) {
+  const filteredChildren = node.children.map((child) => filterByContext(child, contextName)).filter((c) => c !== null);
+  const selfMatches = node.contexts.some((c) => c.toLowerCase() === contextName.toLowerCase());
+  if (!selfMatches && filteredChildren.length === 0) return null;
+  return { ...node, children: filteredChildren };
+}
+function filterWastedRenders(node) {
+  const filteredChildren = node.children.map((child) => filterWastedRenders(child)).filter((c) => c !== null);
+  const isWasted = !node.propsChanged && !node.stateChanged && !node.contextChanged && !node.memoized && node.renderCount > 1;
+  if (!isWasted && filteredChildren.length === 0) return null;
+  return { ...node, children: filteredChildren };
+}
+function sortTree(node, sortBy) {
+  const sortedChildren = node.children.map((child) => sortTree(child, sortBy)).sort((a, b) => {
+    if (sortBy === "renderCount") return b.renderCount - a.renderCount;
+    return a.depth - b.depth;
+  });
+  return { ...node, children: sortedChildren };
+}
+function annotateProviderDepth(node, providerDepth = 0) {
+  const isProvider = node.type === "context.provider";
+  const childProviderDepth = isProvider ? providerDepth + 1 : providerDepth;
+  return {
+    ...node,
+    _providerDepth: providerDepth,
+    children: node.children.map((child) => annotateProviderDepth(child, childProviderDepth))
+  };
+}
+function limitNodes(root, limit) {
+  let remaining = limit;
+  const clip = (node) => {
+    if (remaining <= 0) return null;
+    remaining--;
+    const clippedChildren = [];
+    for (const child of node.children) {
+      const clipped = clip(child);
+      if (clipped !== null) clippedChildren.push(clipped);
+    }
+    return { ...node, children: clippedChildren };
+  };
+  return clip(root) ?? root;
+}
+var BRANCH = "\u251C\u2500\u2500 ";
+var LAST_BRANCH = "\u2514\u2500\u2500 ";
+var VERTICAL = "\u2502   ";
+var EMPTY = "    ";
+function buildTTYLabel(node, showProviderDepth) {
+  const parts = [node.component];
+  switch (node.type) {
+    case "memo":
+      parts.push("[memo]");
+      break;
+    case "forwardRef":
+      parts.push("[forwardRef]");
+      break;
+    case "class":
+      parts.push("[class]");
+      break;
+    case "context.provider":
+      parts.push("[provider]");
+      break;
+    case "context.consumer":
+      parts.push("[consumer]");
+      break;
+  }
+  if (node.renderCount > 0) {
+    const durationStr = node.lastRenderDuration > 0 ? ` ${node.lastRenderDuration.toFixed(2)}ms` : "";
+    parts.push(`(renders:${node.renderCount}${durationStr})`);
+  }
+  if (node.contexts.length > 0) {
+    parts.push(`[ctx:${node.contexts.join(",")}]`);
+  }
+  if (showProviderDepth) {
+    const pd = node._providerDepth;
+    if (pd !== void 0 && pd > 0) {
+      parts.push(`[pd:${pd}]`);
+    }
+  }
+  return parts.join(" ");
+}
+function renderTTYNode(node, prefix, isLast, showProviderDepth, lines) {
+  if (node.type === "host") {
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (child !== void 0) {
+        renderTTYNode(child, prefix, i === node.children.length - 1, showProviderDepth, lines);
+      }
+    }
+    return;
+  }
+  const connector = isLast ? LAST_BRANCH : BRANCH;
+  lines.push(`${prefix}${connector}${buildTTYLabel(node, showProviderDepth)}`);
+  const nextPrefix = prefix + (isLast ? EMPTY : VERTICAL);
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    if (child !== void 0) {
+      renderTTYNode(child, nextPrefix, i === node.children.length - 1, showProviderDepth, lines);
+    }
+  }
+}
+function formatInstrumentTree(root, showProviderDepth = false) {
+  const lines = [];
+  if (root.type !== "host") {
+    lines.push(buildTTYLabel(root, showProviderDepth));
+    for (let i = 0; i < root.children.length; i++) {
+      const child = root.children[i];
+      if (child !== void 0) {
+        renderTTYNode(child, "", i === root.children.length - 1, showProviderDepth, lines);
+      }
+    }
+  } else {
+    for (let i = 0; i < root.children.length; i++) {
+      const child = root.children[i];
+      if (child !== void 0) {
+        renderTTYNode(child, "", i === root.children.length - 1, showProviderDepth, lines);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function runInstrumentTree(options) {
+  const { componentName, filePath } = options;
+  const pool = await getPool();
+  const slot = await pool.acquire();
+  const { page } = slot;
+  try {
+    await page.addInitScript({ content: playwright.getBrowserEntryScript() });
+    const htmlHarness = await buildComponentHarness(
+      filePath,
+      componentName,
+      {},
+      DEFAULT_VIEWPORT_WIDTH
+    );
+    await page.setContent(htmlHarness, { waitUntil: "load" });
+    await page.waitForFunction(
+      () => {
+        const w = window;
+        return w.__SCOPE_RENDER_COMPLETE__ === true;
+      },
+      { timeout: 15e3 }
+    );
+    const renderError = await page.evaluate(
+      () => window.__SCOPE_RENDER_ERROR__ ?? null
+    );
+    if (renderError !== null) {
+      throw new Error(`Component render error: ${renderError}`);
+    }
+    const captureJson = await page.evaluate(async () => {
+      const w = window;
+      if (typeof w.__SCOPE_CAPTURE_JSON__ !== "function") {
+        throw new Error("__SCOPE_CAPTURE_JSON__ not available \u2014 Scope runtime not injected");
+      }
+      return w.__SCOPE_CAPTURE_JSON__({ lightweight: false });
+    });
+    const captureResult = JSON.parse(captureJson);
+    const componentTree = captureResult.tree;
+    if (componentTree === void 0 || componentTree === null) {
+      throw new Error(`No component tree found for "${componentName}"`);
+    }
+    let instrumentRoot = convertToInstrumentNode(componentTree, 0);
+    if (options.usesContext !== void 0) {
+      const filtered = filterByContext(instrumentRoot, options.usesContext);
+      instrumentRoot = filtered !== null ? filtered : { ...instrumentRoot, children: [] };
+    }
+    if (options.wastedRenders === true) {
+      const filtered = filterWastedRenders(instrumentRoot);
+      instrumentRoot = filtered !== null ? filtered : { ...instrumentRoot, children: [] };
+    }
+    if (options.sortBy !== void 0) {
+      instrumentRoot = sortTree(instrumentRoot, options.sortBy);
+    }
+    if (options.providerDepth === true) {
+      instrumentRoot = annotateProviderDepth(instrumentRoot, 0);
+    }
+    if (options.limit !== void 0 && options.limit > 0) {
+      instrumentRoot = limitNodes(instrumentRoot, options.limit);
+    }
+    return instrumentRoot;
+  } finally {
+    pool.release(slot);
+  }
+}
+function createInstrumentTreeCommand() {
+  return new commander.Command("tree").description("Render a component via BrowserPool and output a structured instrumentation tree").argument("<component>", "Component name to instrument (must exist in the manifest)").option("--sort-by <field>", "Sort nodes by field: renderCount | depth").option("--limit <n>", "Limit output to the first N nodes (depth-first)").option("--uses-context <name>", "Filter to components that use a specific context").option("--provider-depth", "Annotate each node with its context-provider nesting depth", false).option(
+    "--wasted-renders",
+    "Filter to components with wasted renders (no prop/state/context changes, not memoized)",
+    false
+  ).option("--format <fmt>", "Output format: json | tree (default: auto)").option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH4).action(async (componentName, opts) => {
+    try {
+      const manifest = loadManifest(opts.manifest);
+      const descriptor = manifest.components[componentName];
+      if (descriptor === void 0) {
+        const available = Object.keys(manifest.components).slice(0, 5).join(", ");
+        throw new Error(
+          `Component "${componentName}" not found in manifest.
+Available: ${available}`
+        );
+      }
+      if (opts.sortBy !== void 0) {
+        const allowed = ["renderCount", "depth"];
+        if (!allowed.includes(opts.sortBy)) {
+          throw new Error(
+            `Unknown --sort-by value "${opts.sortBy}". Allowed: ${allowed.join(", ")}`
+          );
+        }
+      }
+      const rootDir = process.cwd();
+      const filePath = path.resolve(rootDir, descriptor.filePath);
+      process.stderr.write(`Instrumenting ${componentName}\u2026
+`);
+      const instrumentRoot = await runInstrumentTree({
+        componentName,
+        filePath,
+        sortBy: opts.sortBy,
+        limit: opts.limit !== void 0 ? Math.max(1, parseInt(opts.limit, 10)) : void 0,
+        usesContext: opts.usesContext,
+        providerDepth: opts.providerDepth,
+        wastedRenders: opts.wastedRenders
+      });
+      await shutdownPool();
+      const fmt = resolveFormat2(opts.format);
+      if (fmt === "json") {
+        process.stdout.write(`${JSON.stringify(instrumentRoot, null, 2)}
+`);
+      } else {
+        const tree = formatInstrumentTree(instrumentRoot, opts.providerDepth ?? false);
+        process.stdout.write(`${tree}
+`);
+      }
+    } catch (err) {
+      await shutdownPool();
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+function resolveFormat2(formatFlag) {
+  if (formatFlag !== void 0) {
+    const lower = formatFlag.toLowerCase();
+    if (lower !== "json" && lower !== "tree") {
+      throw new Error(`Unknown format "${formatFlag}". Allowed: json, tree`);
+    }
+    return lower;
+  }
+  return isTTY() ? "tree" : "json";
+}
 
 // src/instrument/renders.ts
-var MANIFEST_PATH4 = ".reactscope/manifest.json";
+var MANIFEST_PATH5 = ".reactscope/manifest.json";
 function determineTrigger(event) {
   if (event.forceUpdate) return "force_update";
   if (event.stateChanged) return "state_change";
@@ -1848,26 +2203,26 @@ async function replayInteraction2(page, steps) {
     }
   }
 }
-var _pool = null;
-async function getPool() {
-  if (_pool === null) {
-    _pool = new render.BrowserPool({
+var _pool2 = null;
+async function getPool2() {
+  if (_pool2 === null) {
+    _pool2 = new render.BrowserPool({
       size: { browsers: 1, pagesPerBrowser: 2 },
       viewportWidth: 1280,
       viewportHeight: 800
     });
-    await _pool.init();
+    await _pool2.init();
   }
-  return _pool;
+  return _pool2;
 }
-async function shutdownPool() {
-  if (_pool !== null) {
-    await _pool.close();
-    _pool = null;
+async function shutdownPool2() {
+  if (_pool2 !== null) {
+    await _pool2.close();
+    _pool2 = null;
   }
 }
 async function analyzeRenders(options) {
-  const manifestPath = options.manifestPath ?? MANIFEST_PATH4;
+  const manifestPath = options.manifestPath ?? MANIFEST_PATH5;
   const manifest = loadManifest(manifestPath);
   const descriptor = manifest.components[options.componentName];
   if (descriptor === void 0) {
@@ -1880,7 +2235,7 @@ Available: ${available}`
   const rootDir = process.cwd();
   const filePath = path.resolve(rootDir, descriptor.filePath);
   const htmlHarness = await buildComponentHarness(filePath, options.componentName, {}, 1280);
-  const pool = await getPool();
+  const pool = await getPool2();
   const slot = await pool.acquire();
   const { page } = slot;
   const startMs = performance.now();
@@ -1965,7 +2320,7 @@ function createInstrumentRendersCommand() {
     "--interaction <json>",
     `Interaction sequence JSON, e.g. '[{"action":"click","target":"button"}]'`,
     "[]"
-  ).option("--json", "Output as JSON regardless of TTY", false).option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH4).action(
+  ).option("--json", "Output as JSON regardless of TTY", false).option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH5).action(
     async (componentName, opts) => {
       let interaction = [];
       try {
@@ -1988,7 +2343,7 @@ function createInstrumentRendersCommand() {
           interaction,
           manifestPath: opts.manifest
         });
-        await shutdownPool();
+        await shutdownPool2();
         if (opts.json || !isTTY()) {
           process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
@@ -1997,7 +2352,7 @@ function createInstrumentRendersCommand() {
 `);
         }
       } catch (err) {
-        await shutdownPool();
+        await shutdownPool2();
         process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -2012,6 +2367,7 @@ function createInstrumentCommand() {
   instrumentCmd.addCommand(createInstrumentRendersCommand());
   instrumentCmd.addCommand(createInstrumentHooksCommand());
   instrumentCmd.addCommand(createInstrumentProfileCommand());
+  instrumentCmd.addCommand(createInstrumentTreeCommand());
   return instrumentCmd;
 }
 async function browserCapture(options) {
@@ -2171,24 +2527,24 @@ async function getCompiledCssForClasses(cwd, classes) {
 }
 
 // src/render-commands.ts
-var MANIFEST_PATH5 = ".reactscope/manifest.json";
+var MANIFEST_PATH6 = ".reactscope/manifest.json";
 var DEFAULT_OUTPUT_DIR = ".reactscope/renders";
-var _pool2 = null;
-async function getPool2(viewportWidth, viewportHeight) {
-  if (_pool2 === null) {
-    _pool2 = new render.BrowserPool({
+var _pool3 = null;
+async function getPool3(viewportWidth, viewportHeight) {
+  if (_pool3 === null) {
+    _pool3 = new render.BrowserPool({
       size: { browsers: 1, pagesPerBrowser: 4 },
       viewportWidth,
       viewportHeight
     });
-    await _pool2.init();
+    await _pool3.init();
   }
-  return _pool2;
+  return _pool3;
 }
-async function shutdownPool2() {
-  if (_pool2 !== null) {
-    await _pool2.close();
-    _pool2 = null;
+async function shutdownPool3() {
+  if (_pool3 !== null) {
+    await _pool3.close();
+    _pool3 = null;
   }
 }
 function buildRenderer(filePath, componentName, viewportWidth, viewportHeight) {
@@ -2199,7 +2555,7 @@ function buildRenderer(filePath, componentName, viewportWidth, viewportHeight) {
     _satori: satori,
     async renderCell(props, _complexityClass) {
       const startMs = performance.now();
-      const pool = await getPool2(viewportWidth, viewportHeight);
+      const pool = await getPool3(viewportWidth, viewportHeight);
       const htmlHarness = await buildComponentHarness(
         filePath,
         componentName,
@@ -2296,7 +2652,7 @@ function buildRenderer(filePath, componentName, viewportWidth, viewportHeight) {
   };
 }
 function registerRenderSingle(renderCmd) {
-  renderCmd.command("component <component>", { isDefault: true }).description("Render a single component to PNG or JSON").option("--props <json>", `Inline props JSON, e.g. '{"variant":"primary"}'`).option("--viewport <WxH>", "Viewport size e.g. 1280x720", "375x812").option("--theme <name>", "Theme name from the token system").option("-o, --output <path>", "Write PNG to file instead of stdout").option("--format <fmt>", "Output format: png or json (default: auto)").option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH5).action(
+  renderCmd.command("component <component>", { isDefault: true }).description("Render a single component to PNG or JSON").option("--props <json>", `Inline props JSON, e.g. '{"variant":"primary"}'`).option("--viewport <WxH>", "Viewport size e.g. 1280x720", "375x812").option("--theme <name>", "Theme name from the token system").option("-o, --output <path>", "Write PNG to file instead of stdout").option("--format <fmt>", "Output format: png or json (default: auto)").option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH6).action(
     async (componentName, opts) => {
       try {
         const manifest = loadManifest(opts.manifest);
@@ -2335,7 +2691,7 @@ Available: ${available}`
             }
           }
         );
-        await shutdownPool2();
+        await shutdownPool3();
         if (outcome.crashed) {
           process.stderr.write(`\u2717 Render failed: ${outcome.error.message}
 `);
@@ -2383,7 +2739,7 @@ Available: ${available}`
           );
         }
       } catch (err) {
-        await shutdownPool2();
+        await shutdownPool3();
         process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -2395,7 +2751,7 @@ function registerRenderMatrix(renderCmd) {
   renderCmd.command("matrix <component>").description("Render a component across a matrix of prop axes").option("--axes <spec>", "Axis definitions e.g. 'variant:primary,secondary size:sm,md,lg'").option(
     "--contexts <ids>",
     "Composition context IDs, comma-separated (e.g. centered,rtl,sidebar)"
-  ).option("--stress <ids>", "Stress preset IDs, comma-separated (e.g. text.long,text.unicode)").option("--sprite <path>", "Write sprite sheet PNG to file").option("--format <fmt>", "Output format: json|png|html|csv (default: auto)").option("--concurrency <n>", "Max parallel renders", "8").option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH5).action(
+  ).option("--stress <ids>", "Stress preset IDs, comma-separated (e.g. text.long,text.unicode)").option("--sprite <path>", "Write sprite sheet PNG to file").option("--format <fmt>", "Output format: json|png|html|csv (default: auto)").option("--concurrency <n>", "Max parallel renders", "8").option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH6).action(
     async (componentName, opts) => {
       try {
         const manifest = loadManifest(opts.manifest);
@@ -2468,7 +2824,7 @@ Available: ${available}`
           concurrency
         });
         const result = await matrix.render();
-        await shutdownPool2();
+        await shutdownPool3();
         process.stderr.write(
           `Done. ${result.stats.totalCells} cells, avg ${result.stats.avgRenderTimeMs.toFixed(1)}ms
 `
@@ -2513,7 +2869,7 @@ Available: ${available}`
           process.stdout.write(formatMatrixCsv(componentName, result));
         }
       } catch (err) {
-        await shutdownPool2();
+        await shutdownPool3();
         process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -2522,7 +2878,7 @@ Available: ${available}`
   );
 }
 function registerRenderAll(renderCmd) {
-  renderCmd.command("all").description("Render all components from the manifest").option("--concurrency <n>", "Max parallel renders", "4").option("--output-dir <dir>", "Output directory for renders", DEFAULT_OUTPUT_DIR).option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH5).option("--format <fmt>", "Output format: json|png (default: png)", "png").action(
+  renderCmd.command("all").description("Render all components from the manifest").option("--concurrency <n>", "Max parallel renders", "4").option("--output-dir <dir>", "Output directory for renders", DEFAULT_OUTPUT_DIR).option("--manifest <path>", "Path to manifest.json", MANIFEST_PATH6).option("--format <fmt>", "Output format: json|png (default: png)", "png").action(
     async (opts) => {
       try {
         const manifest = loadManifest(opts.manifest);
@@ -2610,13 +2966,13 @@ function registerRenderAll(renderCmd) {
           workers.push(worker());
         }
         await Promise.all(workers);
-        await shutdownPool2();
+        await shutdownPool3();
         process.stderr.write("\n");
         const summary = formatSummaryText(results, outputDir);
         process.stderr.write(`${summary}
 `);
       } catch (err) {
-        await shutdownPool2();
+        await shutdownPool3();
         process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -2658,26 +3014,26 @@ function createRenderCommand() {
   return renderCmd;
 }
 var DEFAULT_BASELINE_DIR = ".reactscope/baseline";
-var _pool3 = null;
-async function getPool3(viewportWidth, viewportHeight) {
-  if (_pool3 === null) {
-    _pool3 = new render.BrowserPool({
+var _pool4 = null;
+async function getPool4(viewportWidth, viewportHeight) {
+  if (_pool4 === null) {
+    _pool4 = new render.BrowserPool({
       size: { browsers: 1, pagesPerBrowser: 4 },
       viewportWidth,
       viewportHeight
     });
-    await _pool3.init();
+    await _pool4.init();
   }
-  return _pool3;
+  return _pool4;
 }
-async function shutdownPool3() {
-  if (_pool3 !== null) {
-    await _pool3.close();
-    _pool3 = null;
+async function shutdownPool4() {
+  if (_pool4 !== null) {
+    await _pool4.close();
+    _pool4 = null;
   }
 }
 async function renderComponent(filePath, componentName, props, viewportWidth, viewportHeight) {
-  const pool = await getPool3(viewportWidth, viewportHeight);
+  const pool = await getPool4(viewportWidth, viewportHeight);
   const htmlHarness = await buildComponentHarness(filePath, componentName, props, viewportWidth);
   const slot = await pool.acquire();
   const { page } = slot;
@@ -2810,12 +3166,12 @@ async function runBaseline(options = {}) {
   fs.mkdirSync(rendersDir, { recursive: true });
   let manifest$1;
   if (manifestPath !== void 0) {
-    const { readFileSync: readFileSync8 } = await import('fs');
+    const { readFileSync: readFileSync9 } = await import('fs');
     const absPath = path.resolve(rootDir, manifestPath);
     if (!fs.existsSync(absPath)) {
       throw new Error(`Manifest not found at ${absPath}.`);
     }
-    manifest$1 = JSON.parse(readFileSync8(absPath, "utf-8"));
+    manifest$1 = JSON.parse(readFileSync9(absPath, "utf-8"));
     process.stderr.write(`Loaded manifest from ${manifestPath}
 `);
   } else {
@@ -2927,7 +3283,7 @@ async function runBaseline(options = {}) {
     workers.push(worker());
   }
   await Promise.all(workers);
-  await shutdownPool3();
+  await shutdownPool4();
   if (isTTY()) {
     process.stderr.write("\n");
   }
@@ -2976,12 +3332,485 @@ function registerBaselineSubCommand(reportCmd) {
     }
   );
 }
+var DEFAULT_BASELINE_DIR2 = ".reactscope/baseline";
+function loadBaselineCompliance(baselineDir) {
+  const compliancePath = path.resolve(baselineDir, "compliance.json");
+  if (!fs.existsSync(compliancePath)) return null;
+  const raw = JSON.parse(fs.readFileSync(compliancePath, "utf-8"));
+  return raw;
+}
+function loadBaselineRenderJson(baselineDir, componentName) {
+  const jsonPath = path.resolve(baselineDir, "renders", `${componentName}.json`);
+  if (!fs.existsSync(jsonPath)) return null;
+  return JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+}
+var _pool5 = null;
+async function getPool5(viewportWidth, viewportHeight) {
+  if (_pool5 === null) {
+    _pool5 = new render.BrowserPool({
+      size: { browsers: 1, pagesPerBrowser: 4 },
+      viewportWidth,
+      viewportHeight
+    });
+    await _pool5.init();
+  }
+  return _pool5;
+}
+async function shutdownPool5() {
+  if (_pool5 !== null) {
+    await _pool5.close();
+    _pool5 = null;
+  }
+}
+async function renderComponent2(filePath, componentName, props, viewportWidth, viewportHeight) {
+  const pool = await getPool5(viewportWidth, viewportHeight);
+  const htmlHarness = await buildComponentHarness(filePath, componentName, props, viewportWidth);
+  const slot = await pool.acquire();
+  const { page } = slot;
+  try {
+    await page.setContent(htmlHarness, { waitUntil: "load" });
+    await page.waitForFunction(
+      () => {
+        const w = window;
+        return w.__SCOPE_RENDER_COMPLETE__ === true;
+      },
+      { timeout: 15e3 }
+    );
+    const renderError = await page.evaluate(() => {
+      return window.__SCOPE_RENDER_ERROR__ ?? null;
+    });
+    if (renderError !== null) {
+      throw new Error(`Component render error: ${renderError}`);
+    }
+    const rootDir = process.cwd();
+    const classes = await page.evaluate(() => {
+      const set = /* @__PURE__ */ new Set();
+      document.querySelectorAll("[class]").forEach((el) => {
+        for (const c of el.className.split(/\s+/)) {
+          if (c) set.add(c);
+        }
+      });
+      return [...set];
+    });
+    const projectCss = await getCompiledCssForClasses(rootDir, classes);
+    if (projectCss != null && projectCss.length > 0) {
+      await page.addStyleTag({ content: projectCss });
+    }
+    const startMs = performance.now();
+    const rootLocator = page.locator("[data-reactscope-root]");
+    const boundingBox = await rootLocator.boundingBox();
+    if (boundingBox === null || boundingBox.width === 0 || boundingBox.height === 0) {
+      throw new Error(
+        `Component "${componentName}" rendered with zero bounding box \u2014 it may be invisible or not mounted`
+      );
+    }
+    const PAD = 24;
+    const MIN_W = 320;
+    const MIN_H = 200;
+    const clipX = Math.max(0, boundingBox.x - PAD);
+    const clipY = Math.max(0, boundingBox.y - PAD);
+    const rawW = boundingBox.width + PAD * 2;
+    const rawH = boundingBox.height + PAD * 2;
+    const clipW = Math.max(rawW, MIN_W);
+    const clipH = Math.max(rawH, MIN_H);
+    const safeW = Math.min(clipW, viewportWidth - clipX);
+    const safeH = Math.min(clipH, viewportHeight - clipY);
+    const screenshot = await page.screenshot({
+      clip: { x: clipX, y: clipY, width: safeW, height: safeH },
+      type: "png"
+    });
+    const computedStylesRaw = {};
+    const styles = await page.evaluate((sel) => {
+      const el = document.querySelector(sel);
+      if (el === null) return {};
+      const computed = window.getComputedStyle(el);
+      const out = {};
+      for (const prop of [
+        "display",
+        "width",
+        "height",
+        "color",
+        "backgroundColor",
+        "fontSize",
+        "fontFamily",
+        "padding",
+        "margin"
+      ]) {
+        out[prop] = computed.getPropertyValue(prop);
+      }
+      return out;
+    }, "[data-reactscope-root] > *");
+    computedStylesRaw["[data-reactscope-root] > *"] = styles;
+    const renderTimeMs = performance.now() - startMs;
+    return {
+      screenshot,
+      width: Math.round(safeW),
+      height: Math.round(safeH),
+      renderTimeMs,
+      computedStyles: computedStylesRaw
+    };
+  } finally {
+    pool.release(slot);
+  }
+}
+function extractComputedStyles2(computedStylesRaw) {
+  const flat = {};
+  for (const styles of Object.values(computedStylesRaw)) {
+    Object.assign(flat, styles);
+  }
+  const colors = {};
+  const spacing = {};
+  const typography = {};
+  const borders = {};
+  const shadows = {};
+  for (const [prop, value] of Object.entries(flat)) {
+    if (prop === "color" || prop === "backgroundColor") {
+      colors[prop] = value;
+    } else if (prop === "padding" || prop === "margin") {
+      spacing[prop] = value;
+    } else if (prop === "fontSize" || prop === "fontFamily" || prop === "fontWeight" || prop === "lineHeight") {
+      typography[prop] = value;
+    } else if (prop === "borderRadius" || prop === "borderWidth") {
+      borders[prop] = value;
+    } else if (prop === "boxShadow") {
+      shadows[prop] = value;
+    }
+  }
+  return { colors, spacing, typography, borders, shadows };
+}
+function classifyComponent(entry, regressionThreshold) {
+  if (entry.renderFailed) return "unchanged";
+  if (entry.baselineCompliance === null && entry.currentCompliance !== null) {
+    return "added";
+  }
+  if (entry.baselineCompliance !== null && entry.currentCompliance === null) {
+    return "removed";
+  }
+  const delta = entry.complianceDelta;
+  if (delta !== null) {
+    if (delta <= -regressionThreshold) return "compliance_regressed";
+    if (delta >= regressionThreshold) return "compliance_improved";
+  }
+  if (entry.baselineDimensions !== null && entry.currentDimensions !== null) {
+    const dw = Math.abs(entry.currentDimensions.width - entry.baselineDimensions.width);
+    const dh = Math.abs(entry.currentDimensions.height - entry.baselineDimensions.height);
+    if (dw > 10 || dh > 10) return "size_changed";
+  }
+  return "unchanged";
+}
+async function runDiff(options = {}) {
+  const {
+    baselineDir: baselineDirRaw = DEFAULT_BASELINE_DIR2,
+    componentsGlob,
+    manifestPath,
+    viewportWidth = 375,
+    viewportHeight = 812,
+    regressionThreshold = 0.01
+  } = options;
+  const startTime = performance.now();
+  const rootDir = process.cwd();
+  const baselineDir = path.resolve(rootDir, baselineDirRaw);
+  if (!fs.existsSync(baselineDir)) {
+    throw new Error(
+      `Baseline directory not found at "${baselineDir}". Run \`scope report baseline\` first to create a baseline snapshot.`
+    );
+  }
+  const baselineManifestPath = path.resolve(baselineDir, "manifest.json");
+  if (!fs.existsSync(baselineManifestPath)) {
+    throw new Error(
+      `Baseline manifest.json not found at "${baselineManifestPath}". The baseline directory may be incomplete \u2014 re-run \`scope report baseline\`.`
+    );
+  }
+  const baselineManifest = JSON.parse(fs.readFileSync(baselineManifestPath, "utf-8"));
+  const baselineCompliance = loadBaselineCompliance(baselineDir);
+  const baselineComponentNames = new Set(Object.keys(baselineManifest.components));
+  process.stderr.write(
+    `Comparing against baseline at ${baselineDir} (${baselineComponentNames.size} components)
+`
+  );
+  let currentManifest;
+  if (manifestPath !== void 0) {
+    const absPath = path.resolve(rootDir, manifestPath);
+    if (!fs.existsSync(absPath)) {
+      throw new Error(`Manifest not found at "${absPath}".`);
+    }
+    currentManifest = JSON.parse(fs.readFileSync(absPath, "utf-8"));
+    process.stderr.write(`Loaded manifest from ${manifestPath}
+`);
+  } else {
+    process.stderr.write("Scanning for React components\u2026\n");
+    currentManifest = await manifest.generateManifest({ rootDir });
+    const count = Object.keys(currentManifest.components).length;
+    process.stderr.write(`Found ${count} components.
+`);
+  }
+  let componentNames = Object.keys(currentManifest.components);
+  if (componentsGlob !== void 0) {
+    componentNames = componentNames.filter((name) => matchGlob(componentsGlob, name));
+    process.stderr.write(
+      `Filtered to ${componentNames.length} components matching "${componentsGlob}".
+`
+    );
+  }
+  const removedNames = [...baselineComponentNames].filter(
+    (name) => !currentManifest.components[name] && (componentsGlob === void 0 || matchGlob(componentsGlob, name))
+  );
+  const total = componentNames.length;
+  process.stderr.write(`Rendering ${total} components for diff\u2026
+`);
+  const computedStylesMap = /* @__PURE__ */ new Map();
+  const currentRenderMeta = /* @__PURE__ */ new Map();
+  const renderFailures = /* @__PURE__ */ new Set();
+  let completed = 0;
+  const CONCURRENCY = 4;
+  let nextIdx = 0;
+  const renderOne = async (name) => {
+    const descriptor = currentManifest.components[name];
+    if (descriptor === void 0) return;
+    const filePath = path.resolve(rootDir, descriptor.filePath);
+    const outcome = await render.safeRender(
+      () => renderComponent2(filePath, name, {}, viewportWidth, viewportHeight),
+      {
+        props: {},
+        sourceLocation: {
+          file: descriptor.filePath,
+          line: descriptor.loc.start,
+          column: 0
+        }
+      }
+    );
+    completed++;
+    const pct = Math.round(completed / total * 100);
+    if (isTTY()) {
+      process.stderr.write(`${renderProgressBar(completed, total, name, pct)}\r`);
+    }
+    if (outcome.crashed) {
+      renderFailures.add(name);
+      return;
+    }
+    const result = outcome.result;
+    currentRenderMeta.set(name, {
+      width: result.width,
+      height: result.height,
+      renderTimeMs: result.renderTimeMs
+    });
+    computedStylesMap.set(name, extractComputedStyles2(result.computedStyles));
+  };
+  if (total > 0) {
+    const worker = async () => {
+      while (nextIdx < componentNames.length) {
+        const i = nextIdx++;
+        const name = componentNames[i];
+        if (name !== void 0) {
+          await renderOne(name);
+        }
+      }
+    };
+    const workers = [];
+    for (let w = 0; w < Math.min(CONCURRENCY, total); w++) {
+      workers.push(worker());
+    }
+    await Promise.all(workers);
+  }
+  await shutdownPool5();
+  if (isTTY() && total > 0) {
+    process.stderr.write("\n");
+  }
+  const resolver = new tokens.TokenResolver([]);
+  const engine = new tokens.ComplianceEngine(resolver);
+  const currentBatchReport = engine.auditBatch(computedStylesMap);
+  const entries = [];
+  for (const name of componentNames) {
+    const baselineComp = baselineCompliance?.components[name] ?? null;
+    const currentComp = currentBatchReport.components[name] ?? null;
+    const baselineMeta = loadBaselineRenderJson(baselineDir, name);
+    const currentMeta = currentRenderMeta.get(name) ?? null;
+    const failed = renderFailures.has(name);
+    const baselineComplianceScore = baselineComp?.aggregateCompliance ?? null;
+    const currentComplianceScore = currentComp?.compliance ?? null;
+    const delta = baselineComplianceScore !== null && currentComplianceScore !== null ? currentComplianceScore - baselineComplianceScore : null;
+    const partial = {
+      name,
+      baselineCompliance: baselineComplianceScore,
+      currentCompliance: currentComplianceScore,
+      complianceDelta: delta,
+      baselineDimensions: baselineMeta !== null ? { width: baselineMeta.width, height: baselineMeta.height } : null,
+      currentDimensions: currentMeta !== null ? { width: currentMeta.width, height: currentMeta.height } : null,
+      renderTimeMs: currentMeta?.renderTimeMs ?? null,
+      renderFailed: failed
+    };
+    entries.push({ ...partial, status: classifyComponent(partial, regressionThreshold) });
+  }
+  for (const name of removedNames) {
+    const baselineComp = baselineCompliance?.components[name] ?? null;
+    const baselineMeta = loadBaselineRenderJson(baselineDir, name);
+    entries.push({
+      name,
+      status: "removed",
+      baselineCompliance: baselineComp?.aggregateCompliance ?? null,
+      currentCompliance: null,
+      complianceDelta: null,
+      baselineDimensions: baselineMeta !== null ? { width: baselineMeta.width, height: baselineMeta.height } : null,
+      currentDimensions: null,
+      renderTimeMs: null,
+      renderFailed: false
+    });
+  }
+  const summary = {
+    total: entries.length,
+    added: entries.filter((e) => e.status === "added").length,
+    removed: entries.filter((e) => e.status === "removed").length,
+    unchanged: entries.filter((e) => e.status === "unchanged").length,
+    complianceRegressed: entries.filter((e) => e.status === "compliance_regressed").length,
+    complianceImproved: entries.filter((e) => e.status === "compliance_improved").length,
+    sizeChanged: entries.filter((e) => e.status === "size_changed").length,
+    renderFailed: entries.filter((e) => e.renderFailed).length
+  };
+  const hasRegressions = summary.complianceRegressed > 0 || summary.removed > 0 || summary.renderFailed > 0;
+  const wallClockMs = performance.now() - startTime;
+  return {
+    diffedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    baselineDir,
+    summary,
+    components: entries,
+    baselineAggregateCompliance: baselineCompliance?.aggregateCompliance ?? 0,
+    currentAggregateCompliance: currentBatchReport.aggregateCompliance,
+    hasRegressions,
+    wallClockMs
+  };
+}
+var STATUS_ICON = {
+  added: "+",
+  removed: "-",
+  unchanged: " ",
+  compliance_regressed: "\u2193",
+  compliance_improved: "\u2191",
+  size_changed: "~"
+};
+var STATUS_LABEL = {
+  added: "added",
+  removed: "removed",
+  unchanged: "ok",
+  compliance_regressed: "regressed",
+  compliance_improved: "improved",
+  size_changed: "size changed"
+};
+function formatDiffReport(result) {
+  const lines = [];
+  const title = "Scope Report Diff";
+  const rule2 = "\u2501".repeat(Math.max(title.length, 40));
+  lines.push(title, rule2);
+  const complianceDelta = result.currentAggregateCompliance - result.baselineAggregateCompliance;
+  const complianceSign = complianceDelta >= 0 ? "+" : "";
+  lines.push(
+    `Baseline compliance:  ${(result.baselineAggregateCompliance * 100).toFixed(1)}%`,
+    `Current compliance:   ${(result.currentAggregateCompliance * 100).toFixed(1)}%`,
+    `Delta:                ${complianceSign}${(complianceDelta * 100).toFixed(1)}%`,
+    ""
+  );
+  const s = result.summary;
+  lines.push(
+    `Components: ${s.total} total  ` + [
+      s.added > 0 ? `${s.added} added` : "",
+      s.removed > 0 ? `${s.removed} removed` : "",
+      s.complianceRegressed > 0 ? `${s.complianceRegressed} regressed` : "",
+      s.complianceImproved > 0 ? `${s.complianceImproved} improved` : "",
+      s.sizeChanged > 0 ? `${s.sizeChanged} size changed` : "",
+      s.renderFailed > 0 ? `${s.renderFailed} failed` : ""
+    ].filter(Boolean).join("  "),
+    ""
+  );
+  const notable = result.components.filter((e) => e.status !== "unchanged");
+  if (notable.length === 0) {
+    lines.push("  No changes detected.");
+  } else {
+    const nameWidth = Math.max(9, ...notable.map((e) => e.name.length));
+    const header = `${"COMPONENT".padEnd(nameWidth)}  ${"STATUS".padEnd(13)}  ${"COMPLIANCE \u0394".padEnd(13)}  DIMENSIONS`;
+    const divider = "-".repeat(header.length);
+    lines.push(header, divider);
+    for (const entry of notable) {
+      const icon = STATUS_ICON[entry.status];
+      const label = STATUS_LABEL[entry.status].padEnd(13);
+      const name = entry.name.padEnd(nameWidth);
+      let complianceStr = "\u2014".padEnd(13);
+      if (entry.complianceDelta !== null) {
+        const sign = entry.complianceDelta >= 0 ? "+" : "";
+        complianceStr = `${sign}${(entry.complianceDelta * 100).toFixed(1)}%`.padEnd(13);
+      }
+      let dimStr = "\u2014";
+      if (entry.baselineDimensions !== null && entry.currentDimensions !== null) {
+        const b = entry.baselineDimensions;
+        const c = entry.currentDimensions;
+        if (b.width !== c.width || b.height !== c.height) {
+          dimStr = `${b.width}\xD7${b.height} \u2192 ${c.width}\xD7${c.height}`;
+        } else {
+          dimStr = `${c.width}\xD7${c.height}`;
+        }
+      } else if (entry.currentDimensions !== null) {
+        dimStr = `${entry.currentDimensions.width}\xD7${entry.currentDimensions.height}`;
+      } else if (entry.baselineDimensions !== null) {
+        dimStr = `${entry.baselineDimensions.width}\xD7${entry.baselineDimensions.height} (removed)`;
+      }
+      if (entry.renderFailed) {
+        dimStr = "render failed";
+      }
+      lines.push(`${icon} ${name}  ${label}  ${complianceStr}  ${dimStr}`);
+    }
+  }
+  lines.push(
+    "",
+    rule2,
+    result.hasRegressions ? `Diff complete: ${result.summary.complianceRegressed + result.summary.renderFailed} regression(s) detected in ${(result.wallClockMs / 1e3).toFixed(1)}s` : `Diff complete: no regressions in ${(result.wallClockMs / 1e3).toFixed(1)}s`
+  );
+  return lines.join("\n");
+}
+function registerDiffSubCommand(reportCmd) {
+  reportCmd.command("diff").description("Compare the current component library against a saved baseline snapshot").option("-b, --baseline <dir>", "Baseline directory to compare against", DEFAULT_BASELINE_DIR2).option("--components <glob>", "Glob pattern to diff a subset of components").option("--manifest <path>", "Path to an existing manifest.json to use instead of regenerating").option("--viewport <WxH>", "Viewport size, e.g. 1280x720", "375x812").option("--json", "Output diff as JSON instead of human-readable text", false).option("-o, --output <path>", "Write the diff JSON to a file").option(
+    "--regression-threshold <n>",
+    "Minimum compliance drop (0\u20131) to classify as a regression",
+    "0.01"
+  ).action(
+    async (opts) => {
+      try {
+        const [wStr, hStr] = opts.viewport.split("x");
+        const viewportWidth = Number.parseInt(wStr ?? "375", 10);
+        const viewportHeight = Number.parseInt(hStr ?? "812", 10);
+        const regressionThreshold = Number.parseFloat(opts.regressionThreshold);
+        const result = await runDiff({
+          baselineDir: opts.baseline,
+          componentsGlob: opts.components,
+          manifestPath: opts.manifest,
+          viewportWidth,
+          viewportHeight,
+          regressionThreshold
+        });
+        if (opts.output !== void 0) {
+          fs.writeFileSync(opts.output, JSON.stringify(result, null, 2), "utf-8");
+          process.stderr.write(`Diff written to ${opts.output}
+`);
+        }
+        if (opts.json) {
+          process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        } else {
+          process.stdout.write(`${formatDiffReport(result)}
+`);
+        }
+        process.exit(result.hasRegressions ? 1 : 0);
+      } catch (err) {
+        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exit(2);
+      }
+    }
+  );
+}
 
 // src/tree-formatter.ts
-var BRANCH = "\u251C\u2500\u2500 ";
-var LAST_BRANCH = "\u2514\u2500\u2500 ";
-var VERTICAL = "\u2502   ";
-var EMPTY = "    ";
+var BRANCH2 = "\u251C\u2500\u2500 ";
+var LAST_BRANCH2 = "\u2514\u2500\u2500 ";
+var VERTICAL2 = "\u2502   ";
+var EMPTY2 = "    ";
 function buildLabel(node, options) {
   const parts = [node.name];
   if (node.type === "memo") {
@@ -3028,19 +3857,19 @@ function renderNode(node, prefix, isLast, depth, options, lines) {
     }
     return;
   }
-  const connector = isLast ? LAST_BRANCH : BRANCH;
+  const connector = isLast ? LAST_BRANCH2 : BRANCH2;
   const label = buildLabel(node, options);
   lines.push(`${prefix}${connector}${label}`);
   if (options.maxDepth !== void 0 && depth >= options.maxDepth) {
     const childCount = countVisibleDescendants(node, options);
     if (childCount > 0) {
-      const nextPrefix2 = prefix + (isLast ? EMPTY : VERTICAL);
-      lines.push(`${nextPrefix2}${LAST_BRANCH}\u2026 (${childCount} more)`);
+      const nextPrefix2 = prefix + (isLast ? EMPTY2 : VERTICAL2);
+      lines.push(`${nextPrefix2}${LAST_BRANCH2}\u2026 (${childCount} more)`);
     }
     return;
   }
   const visibleChildren = getVisibleChildren(node, options);
-  const nextPrefix = prefix + (isLast ? EMPTY : VERTICAL);
+  const nextPrefix = prefix + (isLast ? EMPTY2 : VERTICAL2);
   for (let i = 0; i < visibleChildren.length; i++) {
     const child = visibleChildren[i];
     if (child !== void 0) {
@@ -3082,7 +3911,7 @@ function formatTree(root, options = {}) {
     if (options.maxDepth === 0) {
       const childCount = countVisibleDescendants(root, options);
       if (childCount > 0) {
-        lines.push(`${LAST_BRANCH}\u2026 (${childCount} more)`);
+        lines.push(`${LAST_BRANCH2}\u2026 (${childCount} more)`);
       }
     } else {
       const visibleChildren = getVisibleChildren(root, options);
@@ -3793,6 +4622,7 @@ function createProgram(options = {}) {
   const existingReportCmd = program.commands.find((c) => c.name() === "report");
   if (existingReportCmd !== void 0) {
     registerBaselineSubCommand(existingReportCmd);
+    registerDiffSubCommand(existingReportCmd);
   }
   return program;
 }