@fairfox/polly 0.1.3 → 0.1.4

package/dist/vendor/visualize/src/cli.js

@@ -0,0 +1,2204 @@
+#!/usr/bin/env bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// vendor/visualize/src/cli.ts
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+
+// vendor/analysis/src/extract/architecture.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+// vendor/analysis/src/extract/manifest.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+class ManifestParser {
+  manifestPath;
+  manifestData;
+  baseDir;
+  constructor(projectRoot) {
+    this.baseDir = projectRoot;
+    this.manifestPath = path.join(projectRoot, "manifest.json");
+    if (!fs.existsSync(this.manifestPath)) {
+      throw new Error(`manifest.json not found at ${this.manifestPath}`);
+    }
+    try {
+      const content = fs.readFileSync(this.manifestPath, "utf-8");
+      this.manifestData = JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to parse manifest.json: ${error}`);
+    }
+  }
+  parse() {
+    const manifest = this.manifestData;
+    return {
+      name: manifest.name || "Unknown Extension",
+      version: manifest.version || "0.0.0",
+      description: manifest.description,
+      manifestVersion: manifest.manifest_version || 2,
+      background: this.parseBackground(),
+      contentScripts: this.parseContentScripts(),
+      popup: this.parsePopup(),
+      options: this.parseOptions(),
+      devtools: this.parseDevtools(),
+      permissions: manifest.permissions || [],
+      hostPermissions: manifest.host_permissions || []
+    };
+  }
+  getContextEntryPoints() {
+    const entryPoints = {};
+    const background = this.parseBackground();
+    if (background) {
+      const entryFile = background.files[0];
+      if (entryFile) {
+        entryPoints.background = this.findSourceFile(entryFile);
+      }
+    }
+    const contentScripts = this.parseContentScripts();
+    if (contentScripts && contentScripts.length > 0) {
+      const firstScript = contentScripts[0].js[0];
+      if (firstScript) {
+        entryPoints.content = this.findSourceFile(firstScript);
+      }
+    }
+    const popup = this.parsePopup();
+    if (popup) {
+      const htmlPath = path.join(this.baseDir, popup.html);
+      const jsPath = this.findAssociatedJS(htmlPath);
+      if (jsPath) {
+        entryPoints.popup = jsPath;
+      }
+    }
+    const options = this.parseOptions();
+    if (options) {
+      const htmlPath = path.join(this.baseDir, options.page);
+      const jsPath = this.findAssociatedJS(htmlPath);
+      if (jsPath) {
+        entryPoints.options = jsPath;
+      }
+    }
+    const devtools = this.parseDevtools();
+    if (devtools) {
+      const htmlPath = path.join(this.baseDir, devtools.page);
+      const jsPath = this.findAssociatedJS(htmlPath);
+      if (jsPath) {
+        entryPoints.devtools = jsPath;
+      }
+    }
+    return entryPoints;
+  }
+  parseBackground() {
+    const bg = this.manifestData.background;
+    if (!bg)
+      return;
+    if (bg.service_worker) {
+      return {
+        type: "service_worker",
+        files: [bg.service_worker]
+      };
+    }
+    if (bg.scripts) {
+      return {
+        type: "script",
+        files: bg.scripts
+      };
+    }
+    if (bg.page) {
+      return {
+        type: "script",
+        files: [bg.page]
+      };
+    }
+    return;
+  }
+  parseContentScripts() {
+    const cs = this.manifestData.content_scripts;
+    if (!cs || !Array.isArray(cs))
+      return;
+    return cs.map((script) => ({
+      matches: script.matches || [],
+      js: script.js || [],
+      css: script.css
+    }));
+  }
+  parsePopup() {
+    const action = this.manifestData.action || this.manifestData.browser_action;
+    if (!action)
+      return;
+    if (action.default_popup) {
+      return {
+        html: action.default_popup,
+        default: true
+      };
+    }
+    return;
+  }
+  parseOptions() {
+    const options = this.manifestData.options_ui || this.manifestData.options_page;
+    if (!options)
+      return;
+    if (typeof options === "string") {
+      return {
+        page: options,
+        openInTab: false
+      };
+    }
+    return {
+      page: options.page,
+      openInTab: options.open_in_tab
+    };
+  }
+  parseDevtools() {
+    const devtools = this.manifestData.devtools_page;
+    if (!devtools)
+      return;
+    return {
+      page: devtools
+    };
+  }
+  findSourceFile(manifestPath) {
+    const candidates = [
+      path.join(this.baseDir, manifestPath),
+      path.join(this.baseDir, manifestPath.replace(/\.js$/, ".ts")),
+      path.join(this.baseDir, "src", manifestPath),
+      path.join(this.baseDir, "src", manifestPath.replace(/\.js$/, ".ts")),
+      path.join(this.baseDir, "src", manifestPath.replace(/\.js$/, ".tsx"))
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return path.join(this.baseDir, manifestPath);
+  }
+  findAssociatedJS(htmlPath) {
+    if (!fs.existsSync(htmlPath)) {
+      return null;
+    }
+    const html = fs.readFileSync(htmlPath, "utf-8");
+    const scriptMatch = html.match(/<script[^>]+src=["']([^"']+)["']/i);
+    if (scriptMatch && scriptMatch[1]) {
+      const scriptPath = scriptMatch[1];
+      const fullPath = path.resolve(path.dirname(htmlPath), scriptPath);
+      if (fs.existsSync(fullPath))
+        return fullPath;
+      if (fs.existsSync(fullPath.replace(/\.js$/, ".ts"))) {
+        return fullPath.replace(/\.js$/, ".ts");
+      }
+      if (fs.existsSync(fullPath.replace(/\.js$/, ".tsx"))) {
+        return fullPath.replace(/\.js$/, ".tsx");
+      }
+    }
+    const baseName = path.basename(htmlPath, ".html");
+    const dir = path.dirname(htmlPath);
+    const candidates = [
+      path.join(dir, `${baseName}.ts`),
+      path.join(dir, `${baseName}.tsx`),
+      path.join(dir, `${baseName}.js`),
+      path.join(dir, "index.ts"),
+      path.join(dir, "index.tsx"),
+      path.join(dir, "index.js")
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+}
+
+// vendor/analysis/src/extract/contexts.ts
+import { Project, Node } from "ts-morph";
+
+class ContextAnalyzer {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new Project({
+      tsConfigFilePath: tsConfigPath
+    });
+  }
+  analyzeContext(contextType, entryPoint, handlers) {
+    const sourceFile = this.project.getSourceFile(entryPoint);
+    if (!sourceFile) {
+      throw new Error(`Could not find source file: ${entryPoint}`);
+    }
+    const chromeAPIs = this.extractChromeAPIs(sourceFile);
+    const dependencies = this.extractDependencies(sourceFile);
+    const description = this.extractDescription(sourceFile);
+    const components = this.isUIContext(contextType) ? this.extractComponents(sourceFile) : undefined;
+    const contextHandlers = handlers.filter((h) => h.node === contextType);
+    return {
+      type: contextType,
+      entryPoint,
+      handlers: contextHandlers,
+      chromeAPIs,
+      externalAPIs: [],
+      components,
+      dependencies,
+      description
+    };
+  }
+  extractChromeAPIs(sourceFile) {
+    const apis = new Set;
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isPropertyAccessExpression(node)) {
+        const text = node.getText();
+        if (text.startsWith("chrome.")) {
+          const match = text.match(/^chrome\.([^.(]+(?:\.[^.(]+)?)/);
+          if (match) {
+            apis.add(match[1]);
+          }
+        }
+        if (text.startsWith("browser.")) {
+          const match = text.match(/^browser\.([^.(]+(?:\.[^.(]+)?)/);
+          if (match) {
+            apis.add(match[1]);
+          }
+        }
+        if (text.includes("bus.adapters.")) {
+          const match = text.match(/bus\.adapters\.([^.(]+)/);
+          if (match) {
+            apis.add(match[1]);
+          }
+        }
+      }
+    });
+    return Array.from(apis).sort();
+  }
+  extractDependencies(sourceFile) {
+    const deps = [];
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = importDecl.getModuleSpecifierValue();
+      deps.push(moduleSpecifier);
+    }
+    return deps;
+  }
+  extractDescription(sourceFile) {
+    const firstStatement = sourceFile.getStatements()[0];
+    if (!firstStatement)
+      return;
+    const leadingComments = firstStatement.getLeadingCommentRanges();
+    if (leadingComments.length === 0)
+      return;
+    const comment = leadingComments[0].getText();
+    const descMatch = comment.match(/@description\s+(.+?)(?:\n|$)/s);
+    if (descMatch) {
+      return descMatch[1].trim();
+    }
+    const lines = comment.split(`
+`).map((l) => l.replace(/^[\s*]+/, "").trim()).filter((l) => l && !l.startsWith("@"));
+    return lines[0] || undefined;
+  }
+  extractComponents(sourceFile) {
+    const components = [];
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isFunctionDeclaration(node)) {
+        const name = node.getName();
+        if (name && this.looksLikeComponent(name, node)) {
+          components.push({
+            name,
+            type: "function",
+            filePath: sourceFile.getFilePath(),
+            line: node.getStartLineNumber(),
+            props: this.extractProps(node),
+            description: this.extractJSDocDescription(node)
+          });
+        }
+      }
+      if (Node.isVariableDeclaration(node)) {
+        const name = node.getName();
+        const initializer = node.getInitializer();
+        if (name && initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
+          if (this.looksLikeComponent(name, initializer)) {
+            components.push({
+              name,
+              type: "function",
+              filePath: sourceFile.getFilePath(),
+              line: node.getStartLineNumber(),
+              props: this.extractProps(initializer),
+              description: this.extractJSDocDescription(node)
+            });
+          }
+        }
+      }
+      if (Node.isClassDeclaration(node)) {
+        const name = node.getName();
+        if (name && this.looksLikeClassComponent(node)) {
+          components.push({
+            name,
+            type: "class",
+            filePath: sourceFile.getFilePath(),
+            line: node.getStartLineNumber(),
+            props: this.extractPropsFromClass(node),
+            description: this.extractJSDocDescription(node)
+          });
+        }
+      }
+    });
+    return components;
+  }
+  looksLikeComponent(name, node) {
+    if (!/^[A-Z]/.test(name))
+      return false;
+    const body = node.getBody();
+    if (!body)
+      return false;
+    let hasJSX = false;
+    if (Node.isBlock(body)) {
+      body.forEachDescendant((child) => {
+        if (Node.isJsxElement(child) || Node.isJsxSelfClosingElement(child)) {
+          hasJSX = true;
+        }
+      });
+    } else {
+      if (Node.isJsxElement(body) || Node.isJsxSelfClosingElement(body)) {
+        hasJSX = true;
+      }
+    }
+    return hasJSX;
+  }
+  looksLikeClassComponent(node) {
+    const extendedTypes = node.getExtends();
+    if (!extendedTypes)
+      return false;
+    const extendsText = extendedTypes.getText();
+    return /Component|PureComponent/.test(extendsText);
+  }
+  extractProps(node) {
+    const params = node.getParameters();
+    if (params.length === 0)
+      return [];
+    const propsParam = params[0];
+    const type = propsParam.getType();
+    const props = [];
+    for (const prop of type.getProperties()) {
+      props.push(prop.getName());
+    }
+    return props;
+  }
+  extractPropsFromClass(node) {
+    const extendedTypes = node.getExtends();
+    if (!extendedTypes)
+      return [];
+    const typeArgs = extendedTypes.getType().getTypeArguments();
+    if (typeArgs.length === 0)
+      return [];
+    const propsType = typeArgs[0];
+    const props = [];
+    for (const prop of propsType.getProperties()) {
+      props.push(prop.getName());
+    }
+    return props;
+  }
+  extractJSDocDescription(node) {
+    const jsDocs = node.getJsDocs();
+    if (jsDocs.length === 0)
+      return;
+    const description = jsDocs[0].getDescription().trim();
+    return description || undefined;
+  }
+  isUIContext(contextType) {
+    return ["popup", "options", "devtools"].includes(contextType);
+  }
+}
+
+// vendor/analysis/src/extract/flows.ts
+import { Project as Project2, Node as Node2 } from "ts-morph";
+
+class FlowAnalyzer {
+  project;
+  handlers;
+  constructor(tsConfigPath, handlers) {
+    this.project = new Project2({
+      tsConfigFilePath: tsConfigPath
+    });
+    this.handlers = handlers;
+  }
+  analyzeFlows() {
+    const flows = [];
+    const handlersByType = new Map;
+    for (const handler of this.handlers) {
+      if (!handlersByType.has(handler.messageType)) {
+        handlersByType.set(handler.messageType, []);
+      }
+      handlersByType.get(handler.messageType).push(handler);
+    }
+    for (const [messageType, handlers] of handlersByType) {
+      const senders = this.findMessageSenders(messageType);
+      for (const sender of senders) {
+        const recipients = handlers.map((h) => h.node);
+        const sequence = this.buildSequence(messageType, sender, handlers);
+        const flowMetadata = this.extractFlowMetadata(sender.file, sender.line);
+        flows.push({
+          messageType,
+          from: sender.context,
+          to: recipients,
+          trigger: flowMetadata.trigger,
+          flowName: flowMetadata.flowName,
+          description: flowMetadata.description,
+          sequence
+        });
+      }
+    }
+    return flows;
+  }
+  findMessageSenders(messageType) {
+    const senders = [];
+    for (const sourceFile of this.project.getSourceFiles()) {
+      const filePath = sourceFile.getFilePath();
+      const context = this.inferContext(filePath);
+      sourceFile.forEachDescendant((node) => {
+        if (Node2.isCallExpression(node)) {
+          const expression = node.getExpression();
+          if (Node2.isPropertyAccessExpression(expression)) {
+            const methodName = expression.getName();
+            if (methodName === "send" || methodName === "emit") {
+              const args = node.getArguments();
+              if (args.length > 0) {
+                const firstArg = args[0];
+                let msgType;
+                if (Node2.isStringLiteral(firstArg)) {
+                  msgType = firstArg.getLiteralValue();
+                } else if (Node2.isObjectLiteralExpression(firstArg)) {
+                  const typeProperty = firstArg.getProperty("type");
+                  if (typeProperty && Node2.isPropertyAssignment(typeProperty)) {
+                    const initializer = typeProperty.getInitializer();
+                    if (initializer && Node2.isStringLiteral(initializer)) {
+                      msgType = initializer.getLiteralValue();
+                    }
+                  }
+                }
+                if (msgType === messageType) {
+                  senders.push({
+                    context,
+                    file: filePath,
+                    line: node.getStartLineNumber()
+                  });
+                }
+              }
+            }
+          }
+        }
+      });
+    }
+    return senders;
+  }
+  buildSequence(messageType, sender, handlers) {
+    const steps = [];
+    let stepNumber = 1;
+    steps.push({
+      step: stepNumber++,
+      action: `${sender.context}.send(${messageType})`,
+      context: sender.context,
+      location: {
+        file: sender.file,
+        line: sender.line
+      }
+    });
+    for (const handler of handlers) {
+      steps.push({
+        step: stepNumber++,
+        action: `${handler.node}.handle(${messageType})`,
+        context: handler.node,
+        location: handler.location
+      });
+      const subsends = this.findMessagesInHandler(handler);
+      for (const subsend of subsends) {
+        steps.push({
+          step: stepNumber++,
+          action: `${handler.node}.send(${subsend.messageType})`,
+          context: handler.node,
+          location: subsend.location
+        });
+      }
+    }
+    return steps;
+  }
+  findMessagesInHandler(handler) {
+    const sends = [];
+    const sourceFile = this.project.getSourceFile(handler.location.file);
+    if (!sourceFile)
+      return sends;
+    const targetLine = handler.location.line;
+    sourceFile.forEachDescendant((node) => {
+      if (Node2.isCallExpression(node)) {
+        const line = node.getStartLineNumber();
+        if (Math.abs(line - targetLine) < 20) {
+          const expression = node.getExpression();
+          if (Node2.isPropertyAccessExpression(expression)) {
+            const methodName = expression.getName();
+            if (methodName === "send" || methodName === "emit") {
+              const args = node.getArguments();
+              if (args.length > 0) {
+                const firstArg = args[0];
+                let messageType;
+                if (Node2.isStringLiteral(firstArg)) {
+                  messageType = firstArg.getLiteralValue();
+                } else if (Node2.isObjectLiteralExpression(firstArg)) {
+                  const typeProperty = firstArg.getProperty("type");
+                  if (typeProperty && Node2.isPropertyAssignment(typeProperty)) {
+                    const initializer = typeProperty.getInitializer();
+                    if (initializer && Node2.isStringLiteral(initializer)) {
+                      messageType = initializer.getLiteralValue();
+                    }
+                  }
+                }
+                if (messageType) {
+                  sends.push({
+                    messageType,
+                    location: {
+                      file: handler.location.file,
+                      line
+                    }
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+    return sends;
+  }
+  extractFlowMetadata(filePath, lineNumber) {
+    const sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile)
+      return {};
+    let targetNode = null;
+    sourceFile.forEachDescendant((node) => {
+      if (node.getStartLineNumber() === lineNumber) {
+        targetNode = node;
+      }
+    });
+    if (!targetNode)
+      return {};
+    const jsDocs = targetNode.getJsDocs?.() || [];
+    if (jsDocs.length === 0)
+      return {};
+    const comment = jsDocs[0].getText();
+    const flowMatch = comment.match(/@flow\s+([^\s]+)/);
+    const flowName = flowMatch ? flowMatch[1] : undefined;
+    const triggerMatch = comment.match(/@trigger\s+(.+?)(?:\n|$)/);
+    const trigger = triggerMatch ? triggerMatch[1].trim() : undefined;
+    const descMatch = comment.match(/@description\s+(.+?)(?:\n|$)/s);
+    const description = descMatch ? descMatch[1].trim() : undefined;
+    return { trigger, flowName, description };
+  }
+  inferContext(filePath) {
+    const path2 = filePath.toLowerCase();
+    if (path2.includes("/background/") || path2.includes("\\background\\")) {
+      return "background";
+    }
+    if (path2.includes("/content/") || path2.includes("\\content\\")) {
+      return "content";
+    }
+    if (path2.includes("/popup/") || path2.includes("\\popup\\")) {
+      return "popup";
+    }
+    if (path2.includes("/devtools/") || path2.includes("\\devtools\\")) {
+      return "devtools";
+    }
+    if (path2.includes("/options/") || path2.includes("\\options\\")) {
+      return "options";
+    }
+    if (path2.includes("/offscreen/") || path2.includes("\\offscreen\\")) {
+      return "offscreen";
+    }
+    return "unknown";
+  }
+}
+
+// vendor/analysis/src/extract/integrations.ts
+import { Project as Project3, Node as Node3 } from "ts-morph";
+
+class IntegrationAnalyzer {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new Project3({
+      tsConfigFilePath: tsConfigPath
+    });
+  }
+  analyzeIntegrations() {
+    const integrations = new Map;
+    const fetchCalls = this.findFetchCalls();
+    for (const call of fetchCalls) {
+      this.addOrMergeIntegration(integrations, this.createAPIIntegration(call));
+    }
+    const websockets = this.findWebSockets();
+    for (const ws of websockets) {
+      this.addOrMergeIntegration(integrations, this.createWebSocketIntegration(ws));
+    }
+    const externalScripts = this.findExternalScripts();
+    for (const script of externalScripts) {
+      this.addOrMergeIntegration(integrations, script);
+    }
+    return Array.from(integrations.values());
+  }
+  findFetchCalls() {
+    const calls = [];
+    for (const sourceFile of this.project.getSourceFiles()) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isCallExpression(node)) {
+          const expression = node.getExpression();
+          if (Node3.isIdentifier(expression) && expression.getText() === "fetch") {
+            const args = node.getArguments();
+            if (args.length > 0) {
+              const urlArg = args[0];
+              let url = null;
+              if (Node3.isStringLiteral(urlArg)) {
+                url = urlArg.getLiteralValue();
+              } else if (Node3.isTemplateExpression(urlArg)) {
+                url = this.extractBaseURL(urlArg.getText());
+              }
+              if (url) {
+                let method = "GET";
+                if (args.length > 1 && Node3.isObjectLiteralExpression(args[1])) {
+                  const options = args[1];
+                  const methodProp = options.getProperty("method");
+                  if (methodProp && Node3.isPropertyAssignment(methodProp)) {
+                    const initializer = methodProp.getInitializer();
+                    if (initializer && Node3.isStringLiteral(initializer)) {
+                      method = initializer.getLiteralValue().toUpperCase();
+                    }
+                  }
+                }
+                const description = this.extractJSDocDescription(node);
+                calls.push({
+                  url,
+                  method,
+                  file: sourceFile.getFilePath(),
+                  line: node.getStartLineNumber(),
+                  description
+                });
+              }
+            }
+          }
+        }
+      });
+    }
+    return calls;
+  }
+  findWebSockets() {
+    const websockets = [];
+    for (const sourceFile of this.project.getSourceFiles()) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isNewExpression(node)) {
+          const expression = node.getExpression();
+          if (Node3.isIdentifier(expression) && expression.getText() === "WebSocket") {
+            const args = node.getArguments();
+            if (args.length > 0 && Node3.isStringLiteral(args[0])) {
+              const url = args[0].getLiteralValue();
+              const description = this.extractJSDocDescription(node);
+              websockets.push({
+                url,
+                file: sourceFile.getFilePath(),
+                line: node.getStartLineNumber(),
+                description
+              });
+            }
+          }
+        }
+      });
+    }
+    return websockets;
+  }
+  findExternalScripts() {
+    const scripts = [];
+    const seen = new Set;
+    for (const sourceFile of this.project.getSourceFiles()) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
+          const packageName = moduleSpecifier.startsWith("@") ? moduleSpecifier.split("/").slice(0, 2).join("/") : moduleSpecifier.split("/")[0];
+          if (!seen.has(packageName)) {
+            seen.add(packageName);
+            scripts.push({
+              type: "external-script",
+              name: packageName,
+              technology: "npm package",
+              usedIn: [sourceFile.getFilePath()],
+              description: `External dependency: ${packageName}`
+            });
+          }
+        }
+      }
+    }
+    return scripts;
+  }
+  createAPIIntegration(call) {
+    const baseURL = this.extractBaseURL(call.url);
+    const name = this.inferAPIName(baseURL);
+    return {
+      type: "api",
+      name,
+      technology: "REST API",
+      url: baseURL,
+      usedIn: [call.file],
+      description: call.description || `External API: ${name}`,
+      calls: [
+        {
+          method: call.method,
+          endpoint: call.url,
+          location: {
+            file: call.file,
+            line: call.line
+          },
+          description: call.description
+        }
+      ]
+    };
+  }
+  createWebSocketIntegration(ws) {
+    const name = this.inferAPIName(ws.url);
+    return {
+      type: "websocket",
+      name,
+      technology: "WebSocket",
+      url: ws.url,
+      usedIn: [ws.file],
+      description: ws.description || `WebSocket connection: ${name}`
+    };
+  }
+  extractBaseURL(url) {
+    url = url.replace(/\$\{[^}]+\}/g, "");
+    url = url.replace(/`/g, "");
+    try {
+      const parsed = new URL(url);
+      return `${parsed.protocol}//${parsed.host}`;
+    } catch {
+      const match = url.match(/https?:\/\/([^/]+)/);
+      return match ? match[0] : url;
+    }
+  }
+  inferAPIName(url) {
+    try {
+      const parsed = new URL(url);
+      const hostname = parsed.hostname;
+      const cleanHost = hostname.replace(/^www\./, "");
+      const parts = cleanHost.split(".");
+      if (parts.length > 0) {
+        return parts[0].charAt(0).toUpperCase() + parts[0].slice(1) + " API";
+      }
+    } catch {}
+    return "External API";
+  }
+  addOrMergeIntegration(map, integration) {
+    const key = `${integration.type}:${integration.name}`;
+    if (map.has(key)) {
+      const existing = map.get(key);
+      existing.usedIn = [...new Set([...existing.usedIn, ...integration.usedIn])];
+      if (integration.calls && existing.calls) {
+        existing.calls.push(...integration.calls);
+      } else if (integration.calls) {
+        existing.calls = integration.calls;
+      }
+    } else {
+      map.set(key, integration);
+    }
+  }
+  extractJSDocDescription(node) {
+    const jsDocs = node.getJsDocs?.() || [];
+    if (jsDocs.length === 0)
+      return;
+    const comment = jsDocs[0].getDescription().trim();
+    return comment || undefined;
+  }
+}
+
+// vendor/analysis/src/extract/handlers.ts
+import { Project as Project4, SyntaxKind as SyntaxKind2, Node as Node4 } from "ts-morph";
+
+class HandlerExtractor {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new Project4({
+      tsConfigFilePath: tsConfigPath
+    });
+  }
+  extractHandlers() {
+    const handlers = [];
+    const messageTypes = new Set;
+    const sourceFiles = this.project.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+      const fileHandlers = this.extractFromFile(sourceFile);
+      handlers.push(...fileHandlers);
+      for (const handler of fileHandlers) {
+        messageTypes.add(handler.messageType);
+      }
+    }
+    return {
+      handlers,
+      messageTypes
+    };
+  }
+  extractFromFile(sourceFile) {
+    const handlers = [];
+    const filePath = sourceFile.getFilePath();
+    const context = this.inferContext(filePath);
+    sourceFile.forEachDescendant((node) => {
+      if (Node4.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node4.isPropertyAccessExpression(expression)) {
+          const methodName = expression.getName();
+          if (methodName === "on") {
+            const handler = this.extractHandler(node, context, filePath);
+            if (handler) {
+              handlers.push(handler);
+            }
+          }
+        }
+      }
+    });
+    return handlers;
+  }
+  extractHandler(callExpr, context, filePath) {
+    const args = callExpr.getArguments();
+    if (args.length < 2) {
+      return null;
+    }
+    const messageTypeArg = args[0];
+    let messageType = null;
+    if (Node4.isStringLiteral(messageTypeArg)) {
+      messageType = messageTypeArg.getLiteralValue();
+    } else if (Node4.isTemplateExpression(messageTypeArg)) {
+      messageType = messageTypeArg.getText().replace(/[`'"]/g, "");
+    }
+    if (!messageType) {
+      return null;
+    }
+    const handlerArg = args[1];
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    if (Node4.isArrowFunction(handlerArg) || Node4.isFunctionExpression(handlerArg)) {
+      this.extractAssignments(handlerArg, assignments);
+      this.extractVerificationConditions(handlerArg, preconditions, postconditions);
+    }
+    const line = callExpr.getStartLineNumber();
+    return {
+      messageType,
+      node: context,
+      assignments,
+      preconditions,
+      postconditions,
+      location: {
+        file: filePath,
+        line
+      }
+    };
+  }
+  extractAssignments(funcNode, assignments) {
+    funcNode.forEachDescendant((node) => {
+      if (Node4.isBinaryExpression(node)) {
+        const operator = node.getOperatorToken().getText();
+        if (operator === "=") {
+          const left = node.getLeft();
+          const right = node.getRight();
+          if (Node4.isPropertyAccessExpression(left)) {
+            const fieldPath = this.getPropertyPath(left);
+            if (fieldPath.startsWith("state.")) {
+              const field = fieldPath.substring(6);
+              const value = this.extractValue(right);
+              if (value !== undefined) {
+                assignments.push({
+                  field,
+                  value
+                });
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  extractVerificationConditions(funcNode, preconditions, postconditions) {
+    const body = funcNode.getBody();
+    const statements = Node4.isBlock(body) ? body.getStatements() : [body];
+    statements.forEach((statement, index) => {
+      if (Node4.isExpressionStatement(statement)) {
+        const expr = statement.getExpression();
+        if (Node4.isCallExpression(expr)) {
+          const callee = expr.getExpression();
+          if (Node4.isIdentifier(callee)) {
+            const functionName = callee.getText();
+            if (functionName === "requires") {
+              const condition = this.extractCondition(expr);
+              if (condition) {
+                preconditions.push(condition);
+              }
+            } else if (functionName === "ensures") {
+              const condition = this.extractCondition(expr);
+              if (condition) {
+                postconditions.push(condition);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  extractCondition(callExpr) {
+    const args = callExpr.getArguments();
+    if (args.length === 0) {
+      return null;
+    }
+    const conditionArg = args[0];
+    const expression = conditionArg.getText();
+    let message;
+    if (args.length >= 2 && Node4.isStringLiteral(args[1])) {
+      message = args[1].getLiteralValue();
+    }
+    const line = callExpr.getStartLineNumber();
+    const column = callExpr.getStartLinePos();
+    return {
+      expression,
+      message,
+      location: {
+        line,
+        column
+      }
+    };
+  }
+  getPropertyPath(node) {
+    const parts = [];
+    let current = node;
+    while (Node4.isPropertyAccessExpression(current)) {
+      parts.unshift(current.getName());
+      current = current.getExpression();
+    }
+    if (Node4.isIdentifier(current)) {
+      parts.unshift(current.getText());
+    }
+    return parts.join(".");
+  }
+  extractValue(node) {
+    if (Node4.isStringLiteral(node)) {
+      return node.getLiteralValue();
+    }
+    if (Node4.isNumericLiteral(node)) {
+      return node.getLiteralValue();
+    }
+    if (node.getKind() === SyntaxKind2.TrueKeyword) {
+      return true;
+    }
+    if (node.getKind() === SyntaxKind2.FalseKeyword) {
+      return false;
+    }
+    if (node.getKind() === SyntaxKind2.NullKeyword) {
+      return null;
+    }
+    return;
+  }
+  inferContext(filePath) {
+    const path2 = filePath.toLowerCase();
+    if (path2.includes("/background/") || path2.includes("\\background\\")) {
+      return "background";
+    }
+    if (path2.includes("/content/") || path2.includes("\\content\\")) {
+      return "content";
+    }
+    if (path2.includes("/popup/") || path2.includes("\\popup\\")) {
+      return "popup";
+    }
+    if (path2.includes("/devtools/") || path2.includes("\\devtools\\")) {
+      return "devtools";
+    }
+    if (path2.includes("/options/") || path2.includes("\\options\\")) {
+      return "options";
+    }
+    if (path2.includes("/offscreen/") || path2.includes("\\offscreen\\")) {
+      return "offscreen";
+    }
+    return "unknown";
+  }
+}
+
+// vendor/analysis/src/extract/adr.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+class ADRExtractor {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  extract() {
+    const adrDir = this.findADRDirectory();
+    if (!adrDir || !fs2.existsSync(adrDir)) {
+      return {
+        adrs: [],
+        directory: adrDir || path2.join(this.projectRoot, "docs", "adr")
+      };
+    }
+    const files = fs2.readdirSync(adrDir).filter((file) => file.endsWith(".md")).map((file) => path2.join(adrDir, file));
+    const adrs = [];
+    for (const file of files) {
+      try {
+        const adr = this.parseADR(file);
+        if (adr) {
+          adrs.push(adr);
+        }
+      } catch (error) {
+        console.warn(`Failed to parse ADR: ${file}`, error);
+      }
+    }
+    adrs.sort((a, b) => a.id.localeCompare(b.id));
+    return {
+      adrs,
+      directory: adrDir
+    };
+  }
+  findADRDirectory() {
+    const candidates = [
+      path2.join(this.projectRoot, "docs", "adr"),
+      path2.join(this.projectRoot, "docs", "architecture", "decisions"),
+      path2.join(this.projectRoot, "adr"),
+      path2.join(this.projectRoot, "architecture", "decisions")
+    ];
+    for (const candidate of candidates) {
+      if (fs2.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  parseADR(filePath) {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const fileName = path2.basename(filePath, ".md");
+    const idMatch = fileName.match(/^(\d+)/);
+    const id = idMatch ? idMatch[1] : fileName;
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : fileName;
+    const status = this.extractStatus(content);
+    const date = this.extractDate(content);
+    const context = this.extractSection(content, "Context");
+    const decision = this.extractSection(content, "Decision");
+    const consequences = this.extractSection(content, "Consequences");
+    const alternativesSection = this.extractSection(content, "Alternatives");
+    const alternatives = alternativesSection ? alternativesSection.split(`
+`).filter((line) => line.trim().startsWith("-")).map((line) => line.replace(/^-\s*/, "").trim()) : undefined;
+    const links = this.extractLinks(content);
+    if (!context || !decision || !consequences) {
+      return null;
+    }
+    return {
+      id,
+      title,
+      status,
+      date,
+      context,
+      decision,
+      consequences,
+      alternatives,
+      links,
+      source: filePath
+    };
+  }
+  extractStatus(content) {
+    const statusMatch = content.match(/Status:\s*(\w+)/i);
+    if (!statusMatch)
+      return "accepted";
+    const status = statusMatch[1].toLowerCase();
+    if (["proposed", "accepted", "deprecated", "superseded"].includes(status)) {
+      return status;
+    }
+    return "accepted";
+  }
+  extractDate(content) {
+    const dateMatch = content.match(/Date:\s*(\d{4}-\d{2}-\d{2})/i) || content.match(/(\d{4}-\d{2}-\d{2})/i);
+    return dateMatch ? dateMatch[1] : new Date().toISOString().split("T")[0];
+  }
+  extractSection(content, sectionName) {
+    const regex = new RegExp(`##\\s+${sectionName}\\s*\\n([\\s\\S]*?)(?=\\n##|$)`, "i");
+    const match = content.match(regex);
+    return match ? match[1].trim() : "";
+  }
+  extractLinks(content) {
+    const links = [];
+    const supersedesMatch = content.match(/Supersedes:\s*ADR-(\d+)/gi);
+    if (supersedesMatch) {
+      for (const match of supersedesMatch) {
+        const idMatch = match.match(/ADR-(\d+)/);
+        if (idMatch) {
+          links.push({
+            type: "supersedes",
+            adrId: idMatch[1]
+          });
+        }
+      }
+    }
+    const supersededByMatch = content.match(/Superseded by:\s*ADR-(\d+)/gi);
+    if (supersededByMatch) {
+      for (const match of supersededByMatch) {
+        const idMatch = match.match(/ADR-(\d+)/);
+        if (idMatch) {
+          links.push({
+            type: "superseded-by",
+            adrId: idMatch[1]
+          });
+        }
+      }
+    }
+    return links;
+  }
+}
+function extractADRs(projectRoot) {
+  const extractor = new ADRExtractor(projectRoot);
+  return extractor.extract();
+}
+
+// vendor/analysis/src/extract/architecture.ts
+class ArchitectureAnalyzer {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async analyze() {
+    const manifestParser = new ManifestParser(this.options.projectRoot);
+    const manifest = manifestParser.parse();
+    const entryPoints = manifestParser.getContextEntryPoints();
+    const handlerExtractor = new HandlerExtractor(this.options.tsConfigPath);
+    const { handlers } = handlerExtractor.extractHandlers();
+    const contextAnalyzer = new ContextAnalyzer(this.options.tsConfigPath);
+    const contexts = {};
+    for (const [contextType, entryPoint] of Object.entries(entryPoints)) {
+      try {
+        const contextInfo = contextAnalyzer.analyzeContext(contextType, entryPoint, handlers);
+        contexts[contextType] = contextInfo;
+      } catch (error) {
+        console.warn(`Failed to analyze context ${contextType}: ${error}`);
+      }
+    }
+    const flowAnalyzer = new FlowAnalyzer(this.options.tsConfigPath, handlers);
+    const messageFlows = flowAnalyzer.analyzeFlows();
+    const integrationAnalyzer = new IntegrationAnalyzer(this.options.tsConfigPath);
+    const integrations = integrationAnalyzer.analyzeIntegrations();
+    this.mergeExternalAPIsIntoContexts(contexts, integrations);
+    const adrs = extractADRs(this.options.projectRoot);
+    const repository = this.extractRepositoryInfo();
+    return {
+      system: {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description
+      },
+      manifest,
+      contexts,
+      messageFlows,
+      integrations,
+      adrs: adrs.adrs.length > 0 ? adrs : undefined,
+      repository
+    };
+  }
+  mergeExternalAPIsIntoContexts(contexts, integrations) {
+    for (const integration of integrations) {
+      if (integration.calls) {
+        for (const call of integration.calls) {
+          for (const [contextType, contextInfo] of Object.entries(contexts)) {
+            if (call.location.file.includes(`/${contextType}/`)) {
+              contextInfo.externalAPIs.push(call);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  extractRepositoryInfo() {
+    const packageJsonPath = path3.join(this.options.projectRoot, "package.json");
+    if (!fs3.existsSync(packageJsonPath)) {
+      return;
+    }
+    try {
+      const content = fs3.readFileSync(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      if (packageJson.repository) {
+        if (typeof packageJson.repository === "string") {
+          return {
+            url: packageJson.repository,
+            type: "git"
+          };
+        }
+        return {
+          url: packageJson.repository.url || packageJson.repository,
+          type: packageJson.repository.type || "git"
+        };
+      }
+    } catch (error) {
+      console.warn(`Failed to parse package.json: ${error}`);
+    }
+    return;
+  }
+}
+async function analyzeArchitecture(options) {
+  const analyzer = new ArchitectureAnalyzer(options);
+  return analyzer.analyze();
+}
+
+// vendor/visualize/src/codegen/structurizr.ts
+class StructurizrDSLGenerator {
+  analysis;
+  options;
+  constructor(analysis, options = {}) {
+    this.analysis = analysis;
+    this.options = {
+      includeDynamicDiagrams: true,
+      includeComponentDiagrams: true,
+      componentDiagramContexts: ["background"],
+      theme: "https://static.structurizr.com/themes/default",
+      ...options
+    };
+  }
+  generate() {
+    const parts = [];
+    parts.push(this.generateWorkspaceHeader());
+    parts.push(this.generateModel());
+    parts.push(this.generateViews());
+    parts.push(this.generateWorkspaceFooter());
+    return parts.join(`
+
+`);
+  }
+  generateWorkspaceHeader() {
+    const { name, description } = this.analysis.system;
+    const parts = [`workspace "${this.escape(name)}" "${this.escape(description || "")}" {`];
+    parts.push("");
+    parts.push("  !identifiers hierarchical");
+    if (this.analysis.adrs && this.analysis.adrs.adrs.length > 0) {
+      parts.push("  !adrs " + this.analysis.adrs.directory);
+    }
+    return parts.join(`
+`);
+  }
+  generateWorkspaceFooter() {
+    return "}";
+  }
+  generateModel() {
+    const parts = [];
+    parts.push("  model {");
+    parts.push(this.generatePeople());
+    parts.push(this.generateExternalSystems());
+    parts.push(this.generateMainSystem());
+    parts.push("  }");
+    return parts.join(`
+
+`);
+  }
+  generatePeople() {
+    return `    user = person "User" "Extension user"`;
+  }
+  generateExternalSystems() {
+    const parts = [];
+    for (const integration of this.analysis.integrations) {
+      if (integration.type === "api" || integration.type === "websocket") {
+        const tech = integration.technology || (integration.type === "websocket" ? "WebSocket" : "REST API");
+        let desc = integration.description || "";
+        if (!desc && integration.calls && integration.calls.length > 0) {
+          const endpoints = integration.calls.slice(0, 3).map((c) => c.endpoint).join(", ");
+          const methods = [...new Set(integration.calls.map((c) => c.method))].join(", ");
+          desc = `External API with endpoints: ${endpoints}. Methods: ${methods}`;
+        }
+        parts.push(`    ${this.toId(integration.name)} = softwareSystem "${this.escape(integration.name)}" "${this.escape(desc)}" {`);
+        parts.push(`      tags "External System" "${integration.type === "websocket" ? "WebSocket" : "REST API"}"`);
+        parts.push(`    }`);
+      }
+    }
+    return parts.join(`
+`);
+  }
+  generateMainSystem() {
+    const parts = [];
+    parts.push(`    extension = softwareSystem "${this.escape(this.analysis.system.name)}" {`);
+    for (const [contextType, contextInfo] of Object.entries(this.analysis.contexts)) {
+      parts.push(this.generateContainer(contextType, contextInfo));
+    }
+    parts.push(this.generateContainerRelationships());
+    parts.push("    }");
+    return parts.join(`
+
+`);
+  }
+  generateContainer(contextType, contextInfo) {
+    const parts = [];
+    const technology = this.getContextTechnology(contextType);
+    const description = contextInfo.description || `${this.capitalize(contextType)} context`;
+    parts.push(`      ${contextType} = container "${this.capitalize(contextType)}" "${this.escape(description)}" "${technology}" {`);
+    if (this.options.includeComponentDiagrams && this.options.componentDiagramContexts?.includes(contextType)) {
+      parts.push(this.generateComponents(contextType, contextInfo));
+      parts.push("");
+      parts.push(this.generateComponentRelationships(contextType, contextInfo));
+    }
+    parts.push("      }");
+    return parts.join(`
+`);
+  }
+  generateComponents(contextType, contextInfo) {
+    const parts = [];
+    const handlersByType = new Map;
+    for (const handler of contextInfo.handlers) {
+      if (!handlersByType.has(handler.messageType)) {
+        handlersByType.set(handler.messageType, []);
+      }
+      handlersByType.get(handler.messageType).push(handler);
+    }
+    for (const [messageType, handlers] of handlersByType) {
+      const componentName = this.toComponentName(messageType);
+      const description = this.generateComponentDescription(messageType, handlers[0]);
+      const tags = this.getComponentTags(messageType, handlers[0]);
+      parts.push(`        ${this.toId(componentName)} = component "${componentName}" "${description}" {`);
+      if (tags.length > 0) {
+        parts.push(`          tags "${tags.join('" "')}"`);
+      }
+      parts.push(`        }`);
+    }
+    if (contextInfo.components) {
+      for (const comp of contextInfo.components) {
+        parts.push(`        ${this.toId(comp.name)} = component "${comp.name}" "${this.escape(comp.description || "UI component")}" {`);
+        parts.push(`          tags "UI Component"`);
+        parts.push(`        }`);
+      }
+    }
+    if (contextInfo.chromeAPIs && contextInfo.chromeAPIs.length > 0) {
+      for (const api of contextInfo.chromeAPIs) {
+        const apiId = this.toId(`chrome_${api}`);
+        parts.push(`        ${apiId} = component "Chrome ${this.capitalize(api)} API" "Browser API for ${api}" {`);
+        parts.push(`          tags "Chrome API" "External"`);
+        parts.push(`        }`);
+      }
+    }
+    return parts.join(`
+`);
+  }
+  generateComponentDescription(messageType, handler) {
+    const type = messageType.toLowerCase();
+    if (type.includes("login")) {
+      return "Authenticates users and establishes sessions";
+    }
+    if (type.includes("logout")) {
+      return "Terminates user sessions and clears credentials";
+    }
+    if (type.includes("add") || type.includes("create")) {
+      const entity = type.replace(/_(add|create)/, "").replace(/_/g, " ");
+      return `Creates new ${entity} items and persists to storage`;
+    }
+    if (type.includes("remove") || type.includes("delete")) {
+      const entity = type.replace(/_(remove|delete)/, "").replace(/_/g, " ");
+      return `Removes ${entity} items from storage`;
+    }
+    if (type.includes("update") || type.includes("toggle")) {
+      const entity = type.replace(/_(update|toggle)/, "").replace(/_/g, " ");
+      return `Updates ${entity} item state and syncs with storage`;
+    }
+    if (type.includes("clear")) {
+      const entity = type.replace(/_clear.*/, "").replace(/_/g, " ");
+      return `Clears all ${entity} items matching criteria`;
+    }
+    if (type.includes("get") || type.includes("fetch") || type.includes("load")) {
+      const entity = type.replace(/_(get|fetch|load)/, "").replace(/_/g, " ");
+      return `Retrieves ${entity} data from storage`;
+    }
+    return `Processes ${messageType} messages and coordinates business logic`;
+  }
+  getComponentTags(messageType, handler) {
+    const tags = ["Message Handler"];
+    const type = messageType.toLowerCase();
+    if (type.includes("login") || type.includes("logout") || type.includes("auth")) {
+      tags.push("Authentication");
+    } else if (type.includes("add") || type.includes("create") || type.includes("update") || type.includes("delete") || type.includes("remove") || type.includes("toggle")) {
+      tags.push("CRUD");
+    } else if (type.includes("get") || type.includes("fetch") || type.includes("load")) {
+      tags.push("Query");
+    }
+    if (type.includes("user")) {
+      tags.push("User Management");
+    }
+    if (type.includes("todo")) {
+      tags.push("Todo Management");
+    }
+    if (type.includes("state")) {
+      tags.push("State Management");
+    }
+    return tags;
+  }
+  generateComponentRelationships(contextType, contextInfo) {
+    const parts = [];
+    const handlersByType = new Map;
+    for (const handler of contextInfo.handlers) {
+      if (!handlersByType.has(handler.messageType)) {
+        handlersByType.set(handler.messageType, []);
+      }
+      handlersByType.get(handler.messageType).push(handler);
+    }
+    if (contextInfo.chromeAPIs && contextInfo.chromeAPIs.length > 0) {
+      for (const api of contextInfo.chromeAPIs) {
+        const apiId = this.toId(`chrome_${api}`);
+        for (const [messageType, handlers] of handlersByType) {
+          const componentId = this.toId(this.toComponentName(messageType));
+          let description = `Uses ${api}`;
+          if (api === "storage") {
+            if (messageType.toLowerCase().includes("get") || messageType.toLowerCase().includes("load")) {
+              description = "Reads from storage";
+            } else {
+              description = "Writes to storage";
+            }
+          } else if (api === "tabs") {
+            description = "Manages browser tabs";
+          } else if (api === "runtime") {
+            description = "Sends messages";
+          }
+          parts.push(`        ${componentId} -> ${apiId} "${description}"`);
+        }
+      }
+    }
+    const stateHandlers = [];
+    const queryHandlers = [];
+    for (const [messageType, handlers] of handlersByType) {
+      const type = messageType.toLowerCase();
+      const componentId = this.toId(this.toComponentName(messageType));
+      if (type.includes("add") || type.includes("create") || type.includes("update") || type.includes("delete") || type.includes("remove") || type.includes("toggle") || type.includes("clear") || type.includes("login") || type.includes("logout")) {
+        stateHandlers.push(componentId);
+      } else if (type.includes("get") || type.includes("fetch") || type.includes("load")) {
+        queryHandlers.push(componentId);
+      }
+    }
+    if (stateHandlers.length > 0 && queryHandlers.length > 0) {
+      for (const queryHandler of queryHandlers) {
+        for (const stateHandler of stateHandlers) {
+          if (queryHandler !== stateHandler) {
+            parts.push(`        ${stateHandler} -> ${queryHandler} "Updates state" {`);
+            parts.push(`          tags "Implicit"`);
+            parts.push(`        }`);
+          }
+        }
+      }
+    }
+    return parts.join(`
+`);
+  }
+  generateContainerRelationships() {
+    const parts = [];
+    const uiContexts = ["popup", "options", "devtools"];
+    for (const contextType of Object.keys(this.analysis.contexts)) {
+      if (uiContexts.includes(contextType)) {
+        parts.push(`      user -> extension.${contextType} "Uses"`);
+      }
+    }
+    for (const flow of this.analysis.messageFlows) {
+      const tech = `Sends ${flow.messageType}`;
+      for (const to of flow.to) {
+        parts.push(`      extension.${flow.from} -> extension.${to} "${tech}"`);
+      }
+    }
+    for (const integration of this.analysis.integrations) {
+      if (integration.type === "api" || integration.type === "websocket") {
+        for (const [contextType, contextInfo] of Object.entries(this.analysis.contexts)) {
+          const usesIntegration = contextInfo.externalAPIs.some((api) => integration.calls?.some((call) => call.endpoint === api.endpoint));
+          if (usesIntegration) {
+            const method = integration.type === "websocket" ? "Connects to" : "Calls";
+            parts.push(`      extension.${contextType} -> ${this.toId(integration.name)} "${method}"`);
+          }
+        }
+      }
+    }
+    return parts.join(`
+`);
+  }
+  generateViews() {
+    const parts = [];
+    parts.push("  views {");
+    parts.push(this.generateSystemContextView());
+    parts.push(this.generateContainerView());
+    if (this.options.includeComponentDiagrams) {
+      for (const contextType of this.options.componentDiagramContexts || []) {
+        if (this.analysis.contexts[contextType]) {
+          parts.push(this.generateComponentView(contextType));
+        }
+      }
+    }
+    if (this.options.includeDynamicDiagrams) {
+      parts.push(this.generateDynamicViews());
+    }
+    parts.push(this.generateStyles());
+    parts.push("  }");
+    if (this.analysis.adrs && this.analysis.adrs.adrs.length > 0) {
+      parts.push("");
+      parts.push(this.generateDocumentation());
+    }
+    return parts.join(`
+
+`);
+  }
+  generateDocumentation() {
+    if (!this.analysis.adrs || this.analysis.adrs.adrs.length === 0) {
+      return "";
+    }
+    const parts = [];
+    parts.push("  documentation {");
+    for (const adr of this.analysis.adrs.adrs) {
+      parts.push(`    decision "${adr.id}" {`);
+      parts.push(`      title "${this.escape(adr.title)}"`);
+      parts.push(`      status "${adr.status}"`);
+      parts.push(`      date "${adr.date}"`);
+      parts.push(`      content "${this.escape(adr.context)}"`);
+      parts.push("    }");
+    }
+    parts.push("  }");
+    return parts.join(`
+`);
+  }
+  generateSystemContextView() {
+    return `    systemContext extension "SystemContext" {
+      include *
+      autoLayout lr
+    }`;
+  }
+  generateContainerView() {
+    return `    container extension "Containers" {
+      include *
+      autoLayout lr
+    }`;
+  }
+  generateComponentView(contextType) {
+    return `    component extension.${contextType} "Components_${this.capitalize(contextType)}" {
+      include *
+      autoLayout tb
+    }`;
+  }
+  generateDynamicViews() {
+    const parts = [];
+    const flowsByDomain = new Map;
+    for (const flow of this.analysis.messageFlows) {
+      const messageType = flow.messageType.toLowerCase();
+      let domain = "general";
+      if (messageType.includes("user") || messageType.includes("login") || messageType.includes("logout") || messageType.includes("auth")) {
+        domain = "authentication";
+      } else if (messageType.includes("todo")) {
+        domain = "todo";
+      } else if (messageType.includes("state")) {
+        domain = "state";
+      }
+      if (!flowsByDomain.has(domain)) {
+        flowsByDomain.set(domain, []);
+      }
+      flowsByDomain.get(domain).push(flow);
+    }
+    let count = 0;
+    for (const [domain, flows] of flowsByDomain) {
+      if (count >= 5)
+        break;
+      const viewName = this.capitalize(domain) + " Flow";
+      parts.push(this.generateDynamicView(viewName, flows, domain));
+      count++;
+    }
+    return parts.join(`
+
+`);
+  }
+  generateDynamicView(flowName, flows, domain) {
+    const parts = [];
+    const description = this.getDynamicViewDescription(domain);
+    parts.push(`    dynamic extension "${flowName}" "${description}" {`);
+    const uiContexts = ["popup", "options", "devtools"];
+    const hasUIFlow = flows.some((f) => uiContexts.includes(f.from));
+    if (hasUIFlow) {
+      const firstFlow = flows.find((f) => uiContexts.includes(f.from));
+      if (firstFlow) {
+        const action = this.getUserAction(domain);
+        parts.push(`      user -> extension.${firstFlow.from} "${action}"`);
+      }
+    }
+    for (const flow of flows) {
+      const messageDesc = this.getMessageDescription(flow.messageType);
+      for (const to of flow.to) {
+        parts.push(`      extension.${flow.from} -> extension.${to} "${messageDesc}"`);
+      }
+    }
+    parts.push("      autoLayout lr");
+    parts.push("    }");
+    return parts.join(`
+`);
+  }
+  getDynamicViewDescription(domain) {
+    const descriptions = {
+      authentication: "User authentication and session management",
+      todo: "Todo item creation, updates, and retrieval",
+      state: "Application state synchronization",
+      general: "Message flow through the system"
+    };
+    return descriptions[domain] || descriptions.general;
+  }
+  getUserAction(domain) {
+    const actions = {
+      authentication: "Initiates login",
+      todo: "Manages todo items",
+      state: "Requests state",
+      general: "Interacts"
+    };
+    return actions[domain] || actions.general;
+  }
+  getMessageDescription(messageType) {
+    const type = messageType.toLowerCase();
+    if (type.includes("login"))
+      return "Authenticate user";
+    if (type.includes("logout"))
+      return "End session";
+    if (type.includes("add") || type.includes("create"))
+      return "Create item";
+    if (type.includes("remove") || type.includes("delete"))
+      return "Delete item";
+    if (type.includes("update") || type.includes("toggle"))
+      return "Update item";
+    if (type.includes("get") || type.includes("fetch"))
+      return "Retrieve data";
+    if (type.includes("clear"))
+      return "Clear items";
+    return messageType;
+  }
+  generateStyles() {
+    const parts = [];
+    parts.push("    styles {");
+    const contextStyles = {
+      background: "#2E7D32",
+      content: "#F57C00",
+      popup: "#1976D2",
+      devtools: "#7B1FA2",
+      options: "#0288D1",
+      ...this.options.styles
+    };
+    for (const [context, color] of Object.entries(contextStyles)) {
+      if (this.analysis.contexts[context]) {
+        parts.push(`      element "extension.${context}" {`);
+        parts.push(`        background ${color}`);
+        parts.push(`        color #ffffff`);
+        parts.push("      }");
+      }
+    }
+    parts.push("    }");
+    return parts.join(`
+`);
+  }
+  getContextTechnology(contextType) {
+    const technologies = {
+      background: "Service Worker / Background Script",
+      content: "Content Script",
+      popup: "Browser Action Popup",
+      devtools: "DevTools Panel",
+      options: "Options Page",
+      offscreen: "Offscreen Document"
+    };
+    return technologies[contextType] || "Extension Context";
+  }
+  toComponentName(messageType) {
+    return messageType.split("_").map((part) => this.capitalize(part.toLowerCase())).join(" ") + " Handler";
+  }
+  toId(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  }
+  toViewName(flowName) {
+    return flowName.split(/[_-]/).map((part) => this.capitalize(part)).join(" ");
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  escape(str) {
+    return str.replace(/"/g, "\\\"");
+  }
+}
+function generateStructurizrDSL(analysis, options) {
+  const generator = new StructurizrDSLGenerator(analysis, options);
+  return generator.generate();
+}
+
+// vendor/visualize/src/runner/export.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import { spawn } from "node:child_process";
+
+class DiagramExporter {
+  static DOCKER_IMAGE = "structurizr/cli:latest";
+  static DEFAULT_TIMEOUT = 120000;
+  async export(options) {
+    const { dslPath, outputDir, timeout = DiagramExporter.DEFAULT_TIMEOUT } = options;
+    if (!fs4.existsSync(dslPath)) {
+      return {
+        success: false,
+        siteDir: "",
+        error: `DSL file not found: ${dslPath}`
+      };
+    }
+    if (!fs4.existsSync(outputDir)) {
+      fs4.mkdirSync(outputDir, { recursive: true });
+    }
+    const dockerAvailable = await this.isDockerAvailable();
+    if (!dockerAvailable) {
+      return {
+        success: false,
+        siteDir: "",
+        error: "Docker is not available. Please install Docker to export the site."
+      };
+    }
+    options.onProgress?.("Checking Structurizr CLI image...");
+    const hasImage = await this.hasImage();
+    if (!hasImage) {
+      options.onProgress?.("Pulling Structurizr CLI image (this may take a moment)...");
+      await this.pullImage((line) => options.onProgress?.(line));
+    }
+    options.onProgress?.("Generating static site...");
+    try {
+      await this.exportStaticSite(dslPath, outputDir, timeout);
+      options.onProgress?.("✓ Static site generated successfully");
+      return {
+        success: true,
+        siteDir: outputDir
+      };
+    } catch (error) {
+      return {
+        success: false,
+        siteDir: "",
+        error: `Failed to export static site: ${error}`
+      };
+    }
+  }
+  async exportStaticSite(dslPath, outputDir, timeout) {
+    const dslDir = path4.dirname(dslPath);
+    const dslFileName = path4.basename(dslPath);
+    const workspaceMount = `${dslDir}:/usr/local/structurizr`;
+    const outputMount = `${outputDir}:/output`;
+    const args = [
+      "run",
+      "--rm",
+      "-v",
+      workspaceMount,
+      "-v",
+      outputMount,
+      DiagramExporter.DOCKER_IMAGE,
+      "export",
+      "-workspace",
+      `/usr/local/structurizr/${dslFileName}`,
+      "-format",
+      "static",
+      "-output",
+      "/output"
+    ];
+    await this.runDocker(args, timeout);
+  }
+  async isDockerAvailable() {
+    try {
+      await this.runCommand("docker", ["--version"], 5000);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async hasImage() {
+    try {
+      const output = await this.runCommand("docker", ["images", "-q", DiagramExporter.DOCKER_IMAGE], 5000);
+      return output.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async pullImage(onProgress) {
+    return new Promise((resolve2, reject) => {
+      const proc = spawn("docker", ["pull", DiagramExporter.DOCKER_IMAGE]);
+      proc.stdout.on("data", (data) => {
+        onProgress?.(data.toString().trim());
+      });
+      proc.stderr.on("data", (data) => {
+        onProgress?.(data.toString().trim());
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve2();
+        } else {
+          reject(new Error(`Failed to pull image, exit code: ${code}`));
+        }
+      });
+      proc.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  async runDocker(args, timeout) {
+    return this.runCommand("docker", args, timeout);
+  }
+  async runCommand(command, args, timeout) {
+    return new Promise((resolve2, reject) => {
+      const proc = spawn(command, args);
+      let stdout = "";
+      let stderr = "";
+      const timer = setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Command timed out after ${timeout}ms`));
+      }, timeout);
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve2(stdout);
+        } else {
+          reject(new Error(`Command failed with exit code ${code}: ${stderr}`));
+        }
+      });
+      proc.on("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+}
+async function exportDiagrams(options) {
+  const exporter = new DiagramExporter;
+  return exporter.export(options);
+}
+
+// vendor/visualize/src/cli.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  gray: "\x1B[90m"
+};
+function color(text, colorCode) {
+  return `${colorCode}${text}${COLORS.reset}`;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "--generate":
+    case "generate":
+      await generateCommand();
+      break;
+    case "--export":
+    case "export":
+      await exportCommand(args.slice(1));
+      break;
+    case "--serve":
+    case "serve":
+    case "--view":
+    case "view":
+      await serveCommand(args.slice(1));
+      break;
+    case "--help":
+    case "help":
+      showHelp();
+      break;
+    default:
+      await generateCommand();
+  }
+}
+async function generateCommand() {
+  console.log(color(`
+\uD83D\uDCCA Analyzing architecture...
+`, COLORS.blue));
+  try {
+    const tsConfigPath = findTsConfig();
+    if (!tsConfigPath) {
+      console.error(color("❌ Could not find tsconfig.json", COLORS.red));
+      console.error("   Run this command from your project root");
+      process.exit(1);
+    }
+    console.log(color(`   Using: ${tsConfigPath}`, COLORS.gray));
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      console.error(color("❌ Could not find manifest.json", COLORS.red));
+      console.error("   Run this command from your extension project root");
+      process.exit(1);
+    }
+    console.log(color(`   Project: ${projectRoot}`, COLORS.gray));
+    const analysis = await analyzeArchitecture({
+      tsConfigPath,
+      projectRoot
+    });
+    console.log(color(`
+✓ Found ${Object.keys(analysis.contexts).length} context(s)`, COLORS.green));
+    console.log(color(`✓ Found ${analysis.messageFlows.length} message flow(s)`, COLORS.green));
+    console.log(color(`✓ Found ${analysis.integrations.length} integration(s)`, COLORS.green));
+    console.log(color(`
+\uD83D\uDCCB Architecture Summary:
+`, COLORS.blue));
+    console.log(color("  Contexts:", COLORS.blue));
+    for (const [contextType, contextInfo] of Object.entries(analysis.contexts)) {
+      console.log(color(`    • ${contextType}`, COLORS.gray));
+      console.log(color(`      - ${contextInfo.handlers.length} handler(s)`, COLORS.gray));
+      console.log(color(`      - ${contextInfo.chromeAPIs.length} Chrome API(s)`, COLORS.gray));
+      if (contextInfo.components) {
+        console.log(color(`      - ${contextInfo.components.length} component(s)`, COLORS.gray));
+      }
+    }
+    if (analysis.integrations.length > 0) {
+      console.log(color(`
+  External Integrations:`, COLORS.blue));
+      for (const integration of analysis.integrations) {
+        console.log(color(`    • ${integration.name} (${integration.type})`, COLORS.gray));
+      }
+    }
+    console.log(color(`
+\uD83D\uDCDD Generating Structurizr DSL...
+`, COLORS.blue));
+    const dsl = generateStructurizrDSL(analysis, {
+      includeDynamicDiagrams: true,
+      includeComponentDiagrams: true,
+      componentDiagramContexts: ["background"]
+    });
+    const outputDir = path5.join(process.cwd(), "docs");
+    if (!fs5.existsSync(outputDir)) {
+      fs5.mkdirSync(outputDir, { recursive: true });
+    }
+    const dslPath = path5.join(outputDir, "architecture.dsl");
+    fs5.writeFileSync(dslPath, dsl, "utf-8");
+    console.log(color(`✅ Architecture documentation generated!
+`, COLORS.green));
+    console.log(`   File: ${color(dslPath, COLORS.blue)}`);
+    console.log();
+    console.log(color("\uD83D\uDCDD Next steps:", COLORS.blue));
+    console.log();
+    console.log("   1. Export diagrams:");
+    console.log("      bun visualize --export");
+    console.log();
+    console.log("   2. View in browser:");
+    console.log("      bun visualize --serve");
+    console.log();
+    console.log(color("\uD83D\uDCA1 Alternative: Structurizr Lite", COLORS.gray));
+    console.log(color("   docker run -it --rm -p 8080:8080 \\", COLORS.gray));
+    console.log(color(`     -v ${outputDir}:/usr/local/structurizr \\`, COLORS.gray));
+    console.log(color("     structurizr/lite", COLORS.gray));
+    console.log();
+    console.log(color("\uD83D\uDCA1 Upload to Structurizr Cloud:", COLORS.gray));
+    console.log(color("   1. Sign up at https://structurizr.com", COLORS.gray));
+    console.log(color("   2. Create a workspace and get API credentials", COLORS.gray));
+    console.log(color("   3. docker run -it --rm -v $(pwd)/docs:/usr/local/structurizr \\", COLORS.gray));
+    console.log(color("        structurizr/cli push -id WORKSPACE_ID -key KEY -secret SECRET \\", COLORS.gray));
+    console.log(color("        -workspace /usr/local/structurizr/architecture.dsl", COLORS.gray));
+    console.log();
+  } catch (error) {
+    console.error(color(`
+❌ Generation failed:`, COLORS.red));
+    console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+    if (error instanceof Error && error.stack) {
+      console.error(color(`
+Stack trace:`, COLORS.gray));
+      console.error(color(error.stack, COLORS.gray));
+    }
+    process.exit(1);
+  }
+}
+async function exportCommand(args) {
+  console.log(color(`
+\uD83D\uDCE4 Generating static site...
+`, COLORS.blue));
+  try {
+    const dslPath = path5.join(process.cwd(), "docs", "architecture.dsl");
+    if (!fs5.existsSync(dslPath)) {
+      console.error(color("❌ DSL file not found", COLORS.red));
+      console.error("   Expected: docs/architecture.dsl");
+      console.error("   Run 'bun visualize' first to generate the DSL");
+      process.exit(1);
+    }
+    const outputDir = path5.join(process.cwd(), "docs", "site");
+    console.log(color(`   DSL: ${dslPath}`, COLORS.gray));
+    console.log(color(`   Output: ${outputDir}`, COLORS.gray));
+    console.log();
+    const result = await exportDiagrams({
+      dslPath,
+      outputDir,
+      onProgress: (message) => {
+        console.log(color(`   ${message}`, COLORS.gray));
+      }
+    });
+    if (!result.success) {
+      console.error(color(`
+❌ Export failed:`, COLORS.red));
+      console.error(`   ${result.error}`);
+      process.exit(1);
+    }
+    console.log(color(`
+✅ Static site generated!
+`, COLORS.green));
+    console.log(color("\uD83D\uDCC1 Location:", COLORS.blue));
+    console.log(`   ${outputDir}`);
+    console.log();
+    console.log(color("\uD83D\uDCA1 Next steps:", COLORS.gray));
+    console.log(color("   • View: bun visualize --serve", COLORS.gray));
+    console.log(color("   • Or open: docs/site/index.html", COLORS.gray));
+    console.log();
+  } catch (error) {
+    console.error(color(`
+❌ Export failed:`, COLORS.red));
+    console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+    if (error instanceof Error && error.stack) {
+      console.error(color(`
+Stack trace:`, COLORS.gray));
+      console.error(color(error.stack, COLORS.gray));
+    }
+    process.exit(1);
+  }
+}
+async function serveCommand(args) {
+  console.log(color(`
+\uD83C\uDF10 Starting static site server...
+`, COLORS.blue));
+  try {
+    const siteDir = path5.join(process.cwd(), "docs", "site");
+    const indexPath = path5.join(siteDir, "index.html");
+    if (!fs5.existsSync(indexPath)) {
+      console.error(color("❌ Static site not found", COLORS.red));
+      console.error("   Expected: docs/site/index.html");
+      console.error("   Run 'bun visualize --export' first to generate the site");
+      process.exit(1);
+    }
+    const portArg = args.find((arg) => arg.startsWith("--port="));
+    const port = portArg ? parseInt(portArg.replace("--port=", "")) : 3000;
+    console.log(color(`   Site: ${siteDir}`, COLORS.gray));
+    console.log(color(`   Port: ${port}`, COLORS.gray));
+    console.log();
+    const BunGlobal = globalThis.Bun;
+    if (!BunGlobal) {
+      throw new Error("Bun runtime is required to run the server");
+    }
+    const server = BunGlobal.serve({
+      port,
+      fetch(req) {
+        const url = new URL(req.url);
+        let filePath = path5.join(siteDir, url.pathname === "/" ? "index.html" : url.pathname);
+        if (fs5.existsSync(filePath) && fs5.statSync(filePath).isFile()) {
+          const file = BunGlobal.file(filePath);
+          return new Response(file);
+        }
+        return new Response("Not found", { status: 404 });
+      }
+    });
+    console.log(color(`
+✅ Server started!
+`, COLORS.green));
+    console.log(`   ${color(`http://localhost:${port}`, COLORS.blue)}`);
+    console.log();
+    console.log(color("Press Ctrl+C to stop the server", COLORS.gray));
+    console.log();
+    if (process.platform === "darwin") {
+      await BunGlobal.spawn(["open", `http://localhost:${port}`]);
+    } else if (process.platform === "linux") {
+      await BunGlobal.spawn(["xdg-open", `http://localhost:${port}`]);
+    } else if (process.platform === "win32") {
+      await BunGlobal.spawn(["cmd", "/c", "start", `http://localhost:${port}`]);
+    }
+    await new Promise(() => {});
+  } catch (error) {
+    console.error(color(`
+❌ Failed to start server:`, COLORS.red));
+    console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+function showHelp() {
+  console.log(`
+${color("bun visualize", COLORS.blue)} - Architecture visualization for web extensions
+
+${color("Commands:", COLORS.blue)}
+
+  ${color("bun visualize", COLORS.green)}
+  ${color("bun visualize --generate", COLORS.green)}
+    Analyze codebase and generate Structurizr DSL
+
+  ${color("bun visualize --export", COLORS.green)}
+    Generate static HTML site with interactive diagrams (requires Docker)
+
+  ${color("bun visualize --serve", COLORS.green)}
+  ${color("bun visualize --serve --port=3000", COLORS.green)}
+    Serve the static site in browser
+
+  ${color("bun visualize --help", COLORS.green)}
+    Show this help message
+
+${color("Getting Started:", COLORS.blue)}
+
+  1. Run ${color("bun visualize", COLORS.green)} from your extension project root
+  2. Find generated ${color("docs/architecture.dsl", COLORS.blue)}
+  3. View with Structurizr Lite (see instructions after generation)
+
+${color("What gets generated:", COLORS.blue)}
+
+  • System Context diagram - Extension + external systems
+  • Container diagram - Extension contexts (background, content, popup, etc.)
+  • Component diagrams - Internal components within contexts
+  • Dynamic diagrams - Message flows between contexts
+
+${color("Learn More:", COLORS.blue)}
+
+  Documentation: https://github.com/fairfox/web-ext
+  Structurizr: https://structurizr.com
+  C4 Model: https://c4model.com
+`);
+}
+function findTsConfig() {
+  const locations = [
+    path5.join(process.cwd(), "tsconfig.json"),
+    path5.join(process.cwd(), "..", "tsconfig.json")
+  ];
+  for (const loc of locations) {
+    if (fs5.existsSync(loc)) {
+      return loc;
+    }
+  }
+  return null;
+}
+function findProjectRoot() {
+  const locations = [process.cwd(), path5.join(process.cwd(), "..")];
+  for (const loc of locations) {
+    const manifestPath = path5.join(loc, "manifest.json");
+    if (fs5.existsSync(manifestPath)) {
+      return loc;
+    }
+  }
+  return null;
+}
+main().catch((error) => {
+  console.error(color(`
+❌ Fatal error:`, COLORS.red));
+  console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+  if (error instanceof Error && error.stack) {
+    console.error(color(`
+Stack trace:`, COLORS.gray));
+    console.error(color(error.stack, COLORS.gray));
+  }
+  process.exit(1);
+});
+
+//# debugId=A7BBE9A42DC131F564756E2164756E21