@fairfox/polly 0.7.1 → 0.7.4

package/dist/tools/teach/src/index.js

@@ -47,8 +47,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-// tools/analysis/src/types/index.ts
-var init_types = () => {};
 
 // node:path
 var exports_path = {};
@@ -390,6 +388,150 @@ var init_path = __esm(() => {
   path_default = posix;
 });
 
+// tools/analysis/src/extract/adr.ts
+var fs = (() => ({}));
+
+class ADRExtractor {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  extract() {
+    const adrDir = this.findADRDirectory();
+    if (!adrDir || !fs.existsSync(adrDir)) {
+      return {
+        adrs: [],
+        directory: adrDir || join(this.projectRoot, "docs", "adr")
+      };
+    }
+    const files = fs.readdirSync(adrDir).filter((file) => file.endsWith(".md")).map((file) => join(adrDir, file));
+    const adrs = [];
+    for (const file of files) {
+      try {
+        const adr = this.parseADR(file);
+        if (adr) {
+          adrs.push(adr);
+        }
+      } catch (error) {
+        if (process.env["POLLY_DEBUG"]) {
+          console.log(`[DEBUG] Failed to parse ADR file ${file}: ${error}`);
+        }
+      }
+    }
+    adrs.sort((a, b) => a.id.localeCompare(b.id));
+    return {
+      adrs,
+      directory: adrDir
+    };
+  }
+  findADRDirectory() {
+    const candidates = [
+      join(this.projectRoot, "docs", "adr"),
+      join(this.projectRoot, "docs", "architecture", "decisions"),
+      join(this.projectRoot, "adr"),
+      join(this.projectRoot, "architecture", "decisions")
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  parseADR(filePath) {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const fileName = basename(filePath, ".md");
+    const idMatch = fileName.match(/^(\d+)/);
+    const id = idMatch?.[1] ?? fileName;
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    const title = 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 && alternatives.length > 0 ? { alternatives } : {},
+      ...links.length > 0 ? { links } : {},
+      source: filePath
+    };
+  }
+  extractStatus(content) {
+    const statusMatch = content.match(/Status:\s*(\w+)/i);
+    if (!statusMatch)
+      return "accepted";
+    const status = statusMatch[1]?.toLowerCase();
+    if (status && ["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);
+    if (dateMatch?.[1]) {
+      return dateMatch[1];
+    }
+    const isoDate = new Date().toISOString().split("T")[0];
+    return isoDate || new Date().toLocaleDateString("en-CA");
+  }
+  extractSection(content, sectionName) {
+    const regex = new RegExp(`##\\s+${sectionName}\\s*\\n([\\s\\S]*?)(?=\\n##|$)`, "i");
+    const match = content.match(regex);
+    return 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+)/);
+        const id = idMatch?.[1];
+        if (id) {
+          links.push({
+            type: "supersedes",
+            adrId: id
+          });
+        }
+      }
+    }
+    const supersededByMatch = content.match(/Superseded by:\s*ADR-(\d+)/gi);
+    if (supersededByMatch) {
+      for (const match of supersededByMatch) {
+        const idMatch = match.match(/ADR-(\d+)/);
+        const id = idMatch?.[1];
+        if (id) {
+          links.push({
+            type: "superseded-by",
+            adrId: id
+          });
+        }
+      }
+    }
+    return links;
+  }
+}
+function extractADRs(projectRoot) {
+  const extractor = new ADRExtractor(projectRoot);
+  return extractor.extract();
+}
+var init_adr = __esm(() => {
+  init_path();
+});
+
 // node:os
 var exports_os = {};
 __export(exports_os, {
@@ -20018,10 +20160,10 @@ var require_typescript = __commonJS((exports, module) => {
     function and(f, g) {
       return (arg) => f(arg) && g(arg);
     }
-    function or(...fs) {
+    function or(...fs2) {
       return (...args) => {
         let lastResult;
-        for (const f of fs) {
+        for (const f of fs2) {
           lastResult = f(...args);
           if (lastResult) {
             return lastResult;
@@ -21550,7 +21692,7 @@ ${lanes.join(`
         init_ts2();
         init_ts_performance();
         ((tracingEnabled2) => {
-          let fs;
+          let fs2;
           let traceCount = 0;
           let traceFd = 0;
           let mode;
@@ -21559,9 +21701,9 @@ ${lanes.join(`
           const legend = [];
           function startTracing2(tracingMode, traceDir, configFilePath) {
             Debug.assert(!tracing, "Tracing already started");
-            if (fs === undefined) {
+            if (fs2 === undefined) {
               try {
-                fs = (()=>{throw new Error("Cannot require module "+"fs");})();
+                fs2 = (()=>{throw new Error("Cannot require module "+"fs");})();
               } catch (e) {
                 throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -21572,8 +21714,8 @@ ${lanes.join(`
             if (legendPath === undefined) {
               legendPath = combinePaths(traceDir, "legend.json");
             }
-            if (!fs.existsSync(traceDir)) {
-              fs.mkdirSync(traceDir, { recursive: true });
+            if (!fs2.existsSync(traceDir)) {
+              fs2.mkdirSync(traceDir, { recursive: true });
             }
             const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
             const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -21583,10 +21725,10 @@ ${lanes.join(`
               tracePath,
               typesPath
             });
-            traceFd = fs.openSync(tracePath, "w");
+            traceFd = fs2.openSync(tracePath, "w");
             tracing = tracingEnabled2;
             const meta = { cat: "__metadata", ph: "M", ts: 1000 * timestamp2(), pid: 1, tid: 1 };
-            fs.writeSync(traceFd, `[
+            fs2.writeSync(traceFd, `[
 ` + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(`,
 `));
           }
@@ -21594,10 +21736,10 @@ ${lanes.join(`
           function stopTracing() {
             Debug.assert(tracing, "Tracing is not in progress");
             Debug.assert(!!typeCatalog.length === (mode !== "server"));
-            fs.writeSync(traceFd, `
+            fs2.writeSync(traceFd, `
 ]
 `);
-            fs.closeSync(traceFd);
+            fs2.closeSync(traceFd);
             tracing = undefined;
             if (typeCatalog.length) {
               dumpTypes(typeCatalog);
@@ -21662,13 +21804,13 @@ ${lanes.join(`
             if (mode === "server" && phase === "checkTypes")
               return;
             mark("beginTracing");
-            fs.writeSync(traceFd, `,
+            fs2.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
             if (extras)
-              fs.writeSync(traceFd, `,${extras}`);
+              fs2.writeSync(traceFd, `,${extras}`);
             if (args)
-              fs.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-            fs.writeSync(traceFd, `}`);
+              fs2.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+            fs2.writeSync(traceFd, `}`);
             mark("endTracing");
             measure("Tracing", "beginTracing", "endTracing");
           }
@@ -21690,9 +21832,9 @@ ${lanes.join(`
             var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
             mark("beginDumpTypes");
             const typesPath = legend[legend.length - 1].typesPath;
-            const typesFd = fs.openSync(typesPath, "w");
+            const typesFd = fs2.openSync(typesPath, "w");
             const recursionIdentityMap = /* @__PURE__ */ new Map;
-            fs.writeSync(typesFd, "[");
+            fs2.writeSync(typesFd, "[");
             const numTypes = types2.length;
             for (let i2 = 0;i2 < numTypes; i2++) {
               const type2 = types2[i2];
@@ -21788,15 +21930,15 @@ ${lanes.join(`
                 flags: Debug.formatTypeFlags(type2.flags).split("|"),
                 display
               };
-              fs.writeSync(typesFd, JSON.stringify(descriptor));
+              fs2.writeSync(typesFd, JSON.stringify(descriptor));
               if (i2 < numTypes - 1) {
-                fs.writeSync(typesFd, `,
+                fs2.writeSync(typesFd, `,
 `);
               }
             }
-            fs.writeSync(typesFd, `]
+            fs2.writeSync(typesFd, `]
 `);
-            fs.closeSync(typesFd);
+            fs2.closeSync(typesFd);
             mark("endDumpTypes");
             measure("Dump types", "beginDumpTypes", "endDumpTypes");
           }
@@ -21804,7 +21946,7 @@ ${lanes.join(`
             if (!legendPath) {
               return;
             }
-            fs.writeFileSync(legendPath, JSON.stringify(legend));
+            fs2.writeFileSync(legendPath, JSON.stringify(legend));
           }
           tracingEnabled2.dumpLegend = dumpLegend;
         })(tracingEnabled || (tracingEnabled = {}));
@@ -21817,7 +21959,7 @@ ${lanes.join(`
       return lowerCase ? name.toLowerCase() : name;
     }
     var SyntaxKind, NodeFlags, ModifierFlags, JsxFlags, RelationComparisonResult, GeneratedIdentifierFlags, TokenFlags, FlowFlags, CommentDirectiveType, OperationCanceledException, FileIncludeKind, FilePreprocessingDiagnosticsKind, EmitOnly, StructureIsReused, ExitStatus, MemberOverrideStatus, UnionReduction, ContextFlags, NodeBuilderFlags, TypeFormatFlags, SymbolFormatFlags, SymbolAccessibility, SyntheticSymbolKind, TypePredicateKind, TypeReferenceSerializationKind, SymbolFlags, EnumKind, CheckFlags, InternalSymbolName, NodeCheckFlags, TypeFlags, ObjectFlags, VarianceFlags, ElementFlags, AccessFlags, IndexFlags, JsxReferenceKind, SignatureKind, SignatureFlags, IndexKind, TypeMapKind, InferencePriority, InferenceFlags, Ternary, AssignmentDeclarationKind, DiagnosticCategory, ModuleResolutionKind, ModuleDetectionKind, WatchFileKind, WatchDirectoryKind, PollingWatchKind, ModuleKind, JsxEmit, ImportsNotUsedAsValues, NewLineKind, ScriptKind, ScriptTarget, LanguageVariant, WatchDirectoryFlags, CharacterCodes, Extension, TransformFlags, SnippetKind, EmitFlags, InternalEmitFlags, ExternalEmitHelpers, EmitHint, OuterExpressionKinds, LexicalEnvironmentFlags, BundleFileSectionKind, ListFormat, PragmaKindFlags, commentPragmas, JSDocParsingMode;
-    var init_types2 = __esm2({
+    var init_types = __esm2({
       "src/compiler/types.ts"() {
         SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => {
           SyntaxKind5[SyntaxKind5["Unknown"] = 0] = "Unknown";
@@ -25138,7 +25280,7 @@ ${lanes.join(`
     var Diagnostics;
     var init_diagnosticInformationMap_generated = __esm2({
       "src/compiler/diagnosticInformationMap.generated.ts"() {
-        init_types2();
+        init_types();
         Diagnostics = {
           Unterminated_string_literal: diag(1002, 1, "Unterminated_string_literal_1002", "Unterminated string literal."),
           Identifier_expected: diag(1003, 1, "Identifier_expected_1003", "Identifier expected."),
@@ -126749,7 +126891,7 @@ ${lanes.join(`
         init_performanceCore();
         init_perfLogger();
         init_tracing();
-        init_types2();
+        init_types();
         init_sys();
         init_path2();
         init_diagnosticInformationMap_generated();
@@ -126859,13 +127001,13 @@ ${lanes.join(`
     `;
       }
     });
-    var init_types22 = __esm2({
+    var init_types2 = __esm2({
       "src/jsTyping/types.ts"() {}
     });
     var init_ts_server = __esm2({
       "src/jsTyping/_namespaces/ts.server.ts"() {
         init_shared();
-        init_types22();
+        init_types2();
       }
     });
     function isTypingUpToDate(cachedTyping, availableTypingVersions) {
@@ -212515,31 +212657,31 @@ interface CSSNumericArray{[Symbol.iterator]():IterableIterator<CSSNumericValue>;
         yield path2;
     }
   }
-  var fs = runtime.fs;
+  var fs2 = runtime.fs;
 
   class RealFileSystemHost {
     async delete(path2) {
       try {
-        await fs.delete(path2);
+        await fs2.delete(path2);
       } catch (err) {
         throw this.#getFileNotFoundErrorIfNecessary(err, path2);
       }
     }
     deleteSync(path2) {
       try {
-        fs.deleteSync(path2);
+        fs2.deleteSync(path2);
       } catch (err) {
         throw this.#getFileNotFoundErrorIfNecessary(err, path2);
       }
     }
     readDirSync(dirPath) {
       try {
-        const entries = fs.readDirSync(dirPath);
+        const entries = fs2.readDirSync(dirPath);
         for (const entry of entries) {
           entry.name = FileUtils.pathJoin(dirPath, entry.name);
           if (entry.isSymlink) {
             try {
-              const info = fs.statSync(entry.name);
+              const info = fs2.statSync(entry.name);
               if (info != null) {
                 entry.isDirectory = info.isDirectory();
                 entry.isFile = info.isFile();
@@ -212554,84 +212696,84 @@ interface CSSNumericArray{[Symbol.iterator]():IterableIterator<CSSNumericValue>;
     }
     async readFile(filePath, encoding = "utf-8") {
       try {
-        return await fs.readFile(filePath, encoding);
+        return await fs2.readFile(filePath, encoding);
       } catch (err) {
         throw this.#getFileNotFoundErrorIfNecessary(err, filePath);
       }
     }
     readFileSync(filePath, encoding = "utf-8") {
       try {
-        return fs.readFileSync(filePath, encoding);
+        return fs2.readFileSync(filePath, encoding);
       } catch (err) {
         throw this.#getFileNotFoundErrorIfNecessary(err, filePath);
       }
     }
     async writeFile(filePath, fileText) {
-      return fs.writeFile(filePath, fileText);
+      return fs2.writeFile(filePath, fileText);
     }
     writeFileSync(filePath, fileText) {
-      fs.writeFileSync(filePath, fileText);
+      fs2.writeFileSync(filePath, fileText);
     }
     mkdir(dirPath) {
-      return fs.mkdir(dirPath);
+      return fs2.mkdir(dirPath);
     }
     mkdirSync(dirPath) {
-      fs.mkdirSync(dirPath);
+      fs2.mkdirSync(dirPath);
     }
     move(srcPath, destPath) {
-      return fs.move(srcPath, destPath);
+      return fs2.move(srcPath, destPath);
     }
     moveSync(srcPath, destPath) {
-      fs.moveSync(srcPath, destPath);
+      fs2.moveSync(srcPath, destPath);
     }
     copy(srcPath, destPath) {
-      return fs.copy(srcPath, destPath);
+      return fs2.copy(srcPath, destPath);
     }
     copySync(srcPath, destPath) {
-      fs.copySync(srcPath, destPath);
+      fs2.copySync(srcPath, destPath);
     }
     async fileExists(filePath) {
       try {
-        return (await fs.stat(filePath))?.isFile() ?? false;
+        return (await fs2.stat(filePath))?.isFile() ?? false;
       } catch {
         return false;
       }
     }
     fileExistsSync(filePath) {
       try {
-        return fs.statSync(filePath)?.isFile() ?? false;
+        return fs2.statSync(filePath)?.isFile() ?? false;
       } catch {
         return false;
       }
     }
     async directoryExists(dirPath) {
       try {
-        return (await fs.stat(dirPath))?.isDirectory() ?? false;
+        return (await fs2.stat(dirPath))?.isDirectory() ?? false;
       } catch {
         return false;
       }
     }
     directoryExistsSync(dirPath) {
       try {
-        return fs.statSync(dirPath)?.isDirectory() ?? false;
+        return fs2.statSync(dirPath)?.isDirectory() ?? false;
       } catch {
         return false;
       }
     }
     realpathSync(path2) {
-      return fs.realpathSync(path2);
+      return fs2.realpathSync(path2);
     }
     getCurrentDirectory() {
-      return FileUtils.standardizeSlashes(fs.getCurrentDirectory());
+      return FileUtils.standardizeSlashes(fs2.getCurrentDirectory());
     }
     glob(patterns) {
-      return fs.glob(backSlashesToForward(patterns));
+      return fs2.glob(backSlashesToForward(patterns));
     }
     globSync(patterns) {
-      return fs.globSync(backSlashesToForward(patterns));
+      return fs2.globSync(backSlashesToForward(patterns));
     }
     isCaseSensitive() {
-      return fs.isCaseSensitive();
+      return fs2.isCaseSensitive();
     }
     #getDirectoryNotFoundErrorIfNecessary(err, path2) {
       return FileUtils.isNotExistsError(err) ? new exports.errors.DirectoryNotFoundError(FileUtils.getStandardizedAbsolutePath(this, path2)) : err;
@@ -235621,6 +235763,479 @@ Node text: ${this.#forgottenText}`;
   exports.setScopeForNode = setScopeForNode;
 });
 
+// tools/analysis/src/extract/contexts.ts
+class ContextAnalyzer {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new import_ts_morph.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 ? { components } : {},
+      dependencies,
+      ...description ? { description } : {}
+    };
+  }
+  extractChromeAPIs(sourceFile) {
+    const apis = new Set;
+    sourceFile.forEachDescendant((node) => {
+      if (import_ts_morph.Node.isPropertyAccessExpression(node)) {
+        const text = node.getText();
+        this.detectAPIPattern(text, apis);
+      }
+    });
+    return Array.from(apis).sort();
+  }
+  detectAPIPattern(text, apis) {
+    if (text.startsWith("chrome.")) {
+      const api = this.extractAPIFromPrefix(text, "chrome");
+      if (api)
+        apis.add(api);
+      return;
+    }
+    if (text.startsWith("browser.")) {
+      const api = this.extractAPIFromPrefix(text, "browser");
+      if (api)
+        apis.add(api);
+      return;
+    }
+    if (text.includes("bus.adapters.")) {
+      const api = this.extractAPIFromBusAdapter(text);
+      if (api)
+        apis.add(api);
+    }
+  }
+  extractAPIFromPrefix(text, prefix) {
+    const pattern = new RegExp(`^${prefix}\\.([^.(]+(?:\\.[^.(]+)?)`);
+    const match = text.match(pattern);
+    return match?.[1] || null;
+  }
+  extractAPIFromBusAdapter(text) {
+    const match = text.match(/bus\.adapters\.([^.(]+)/);
+    return match?.[1] || null;
+  }
+  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) => {
+      this.extractFunctionComponent(node, sourceFile, components);
+      this.extractArrowFunctionComponent(node, sourceFile, components);
+      this.extractClassComponent(node, sourceFile, components);
+    });
+    return components;
+  }
+  extractFunctionComponent(node, sourceFile, components) {
+    if (!import_ts_morph.Node.isFunctionDeclaration(node))
+      return;
+    const name = node.getName();
+    if (!name || !this.looksLikeComponent(name, node))
+      return;
+    const description = this.extractJSDocDescription(node);
+    components.push({
+      name,
+      type: "function",
+      filePath: sourceFile.getFilePath(),
+      line: node.getStartLineNumber(),
+      props: this.extractProps(node),
+      ...description ? { description } : {}
+    });
+  }
+  extractArrowFunctionComponent(node, sourceFile, components) {
+    if (!import_ts_morph.Node.isVariableDeclaration(node))
+      return;
+    const name = node.getName();
+    const initializer = node.getInitializer();
+    if (!name || !initializer)
+      return;
+    if (!import_ts_morph.Node.isArrowFunction(initializer) && !import_ts_morph.Node.isFunctionExpression(initializer))
+      return;
+    if (!this.looksLikeComponent(name, initializer))
+      return;
+    const description = this.extractJSDocDescription(node);
+    components.push({
+      name,
+      type: "function",
+      filePath: sourceFile.getFilePath(),
+      line: node.getStartLineNumber(),
+      props: this.extractProps(initializer),
+      ...description ? { description } : {}
+    });
+  }
+  extractClassComponent(node, sourceFile, components) {
+    if (!import_ts_morph.Node.isClassDeclaration(node))
+      return;
+    const name = node.getName();
+    if (!name || !this.looksLikeClassComponent(node))
+      return;
+    const description = this.extractJSDocDescription(node);
+    components.push({
+      name,
+      type: "class",
+      filePath: sourceFile.getFilePath(),
+      line: node.getStartLineNumber(),
+      props: this.extractPropsFromClass(node),
+      ...description ? { description } : {}
+    });
+  }
+  looksLikeComponent(name, node) {
+    if (!/^[A-Z]/.test(name))
+      return false;
+    const body = node.getBody();
+    if (!body)
+      return false;
+    let hasJSX = false;
+    if (import_ts_morph.Node.isBlock(body)) {
+      body.forEachDescendant((child) => {
+        if (import_ts_morph.Node.isJsxElement(child) || import_ts_morph.Node.isJsxSelfClosingElement(child)) {
+          hasJSX = true;
+        }
+      });
+    } else if (import_ts_morph.Node.isJsxElement(body) || import_ts_morph.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 type2 = propsParam.getType();
+    const props = [];
+    for (const prop of type2.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);
+  }
+}
+var import_ts_morph;
+var init_contexts = __esm(() => {
+  import_ts_morph = __toESM(require_ts_morph(), 1);
+});
+
+// tools/analysis/src/extract/flows.ts
+class FlowAnalyzer {
+  project;
+  handlers;
+  constructor(tsConfigPath, handlers) {
+    this.project = new import_ts_morph2.Project({
+      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,
+          ...flowMetadata.trigger ? { trigger: flowMetadata.trigger } : {},
+          ...flowMetadata.flowName ? { flowName: flowMetadata.flowName } : {},
+          ...flowMetadata.description ? { 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) => {
+        this.processMessageSender(node, messageType, context, filePath, senders);
+      });
+    }
+    return senders;
+  }
+  processMessageSender(node, messageType, context, filePath, senders) {
+    if (!import_ts_morph2.Node.isCallExpression(node)) {
+      return;
+    }
+    const expression = node.getExpression();
+    if (import_ts_morph2.Node.isPropertyAccessExpression(expression)) {
+      this.processPropertyAccessSender(node, expression, messageType, context, filePath, senders);
+    } else if (import_ts_morph2.Node.isIdentifier(expression)) {
+      this.processIdentifierSender(node, expression, messageType, context, filePath, senders);
+    }
+  }
+  processPropertyAccessSender(node, expression, messageType, context, filePath, senders) {
+    if (!import_ts_morph2.Node.isPropertyAccessExpression(expression)) {
+      return;
+    }
+    const methodName = expression.getName();
+    if (!this.isMessageSendMethod(methodName)) {
+      return;
+    }
+    const args = node.getArguments();
+    if (args.length === 0) {
+      return;
+    }
+    const msgType = this.extractMessageTypeFromArg(args[0]);
+    if (msgType === messageType) {
+      senders.push({
+        context,
+        file: filePath,
+        line: node.getStartLineNumber()
+      });
+    }
+  }
+  processIdentifierSender(node, expression, messageType, context, filePath, senders) {
+    if (!import_ts_morph2.Node.isIdentifier(expression)) {
+      return;
+    }
+    if (expression.getText() !== "postMessage") {
+      return;
+    }
+    const args = node.getArguments();
+    if (args.length === 0) {
+      return;
+    }
+    const msgType = this.extractMessageTypeFromArg(args[0]);
+    if (msgType === messageType) {
+      senders.push({
+        context,
+        file: filePath,
+        line: node.getStartLineNumber()
+      });
+    }
+  }
+  isMessageSendMethod(methodName) {
+    return methodName === "send" || methodName === "emit" || methodName === "postMessage" || methodName === "broadcast";
+  }
+  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) => {
+      this.processSendCall(node, targetLine, handler.location.file, sends);
+    });
+    return sends;
+  }
+  processSendCall(node, targetLine, filePath, sends) {
+    if (!import_ts_morph2.Node.isCallExpression(node)) {
+      return;
+    }
+    const line = node.getStartLineNumber();
+    if (!this.isNearLine(line, targetLine)) {
+      return;
+    }
+    const expression = node.getExpression();
+    if (!this.isSendOrEmitCall(expression)) {
+      return;
+    }
+    const args = node.getArguments();
+    if (args.length === 0) {
+      return;
+    }
+    const messageType = this.extractMessageTypeFromArg(args[0]);
+    if (messageType) {
+      sends.push({
+        messageType,
+        location: { file: filePath, line }
+      });
+    }
+  }
+  isNearLine(line, targetLine) {
+    return Math.abs(line - targetLine) < 20;
+  }
+  isSendOrEmitCall(expression) {
+    if (!import_ts_morph2.Node.isPropertyAccessExpression(expression)) {
+      return false;
+    }
+    const methodName = expression.getName();
+    return methodName === "send" || methodName === "emit";
+  }
+  extractMessageTypeFromArg(arg) {
+    if (import_ts_morph2.Node.isStringLiteral(arg)) {
+      return arg.getLiteralValue();
+    }
+    if (import_ts_morph2.Node.isObjectLiteralExpression(arg)) {
+      return this.extractMessageTypeFromObject(arg);
+    }
+    return;
+  }
+  extractMessageTypeFromObject(obj) {
+    if (!import_ts_morph2.Node.isObjectLiteralExpression(obj)) {
+      return;
+    }
+    const typeProperty = obj.getProperty("type");
+    if (!typeProperty || !import_ts_morph2.Node.isPropertyAssignment(typeProperty)) {
+      return;
+    }
+    const initializer = typeProperty.getInitializer();
+    if (!initializer || !import_ts_morph2.Node.isStringLiteral(initializer)) {
+      return;
+    }
+    return initializer.getLiteralValue();
+  }
+  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 path = filePath.toLowerCase();
+    const contextPatterns = [
+      { context: "background", patterns: ["/background/", "\\background\\"] },
+      { context: "content", patterns: ["/content/", "\\content\\"] },
+      { context: "popup", patterns: ["/popup/", "\\popup\\"] },
+      { context: "devtools", patterns: ["/devtools/", "\\devtools\\"] },
+      { context: "options", patterns: ["/options/", "\\options\\"] },
+      { context: "offscreen", patterns: ["/offscreen/", "\\offscreen\\"] },
+      { context: "server", patterns: ["/server/", "\\server\\", "/server."] },
+      { context: "client", patterns: ["/client/", "\\client\\", "/client."] },
+      { context: "worker", patterns: ["/worker/", "\\worker\\", "service-worker"] }
+    ];
+    for (const { context, patterns } of contextPatterns) {
+      if (patterns.some((pattern) => path.includes(pattern))) {
+        return context;
+      }
+    }
+    return "unknown";
+  }
+}
+var import_ts_morph2;
+var init_flows = __esm(() => {
+  import_ts_morph2 = __toESM(require_ts_morph(), 1);
+});
+
 // tools/analysis/src/extract/relationships.ts
 class RelationshipExtractor {
   extractFromHandler(handlerNode, sourceFile, handlerName) {
@@ -235635,16 +236250,16 @@ class RelationshipExtractor {
     });
   }
   processDescendantNode(descendant, sourceFile, handlerName, relationships, visited) {
-    if (import_ts_morph.Node.isCallExpression(descendant)) {
+    if (import_ts_morph3.Node.isCallExpression(descendant)) {
       this.processCallExpression(descendant, sourceFile, handlerName, relationships, visited);
     }
-    if (import_ts_morph.Node.isAwaitExpression(descendant)) {
+    if (import_ts_morph3.Node.isAwaitExpression(descendant)) {
       const rel = this.extractFromDatabaseCall(descendant, handlerName);
       if (rel) {
         relationships.push(rel);
       }
     }
-    if (import_ts_morph.Node.isCallExpression(descendant) && descendant.getExpression().getText() === "fetch") {
+    if (import_ts_morph3.Node.isCallExpression(descendant) && descendant.getExpression().getText() === "fetch") {
       const rel = this.extractFromFetchCall(descendant, handlerName);
       if (rel) {
         relationships.push(rel);
@@ -235653,11 +236268,11 @@ class RelationshipExtractor {
   }
   processCallExpression(callExpr, sourceFile, handlerName, relationships, visited) {
     const expr = callExpr.getExpression();
-    if (import_ts_morph.Node.isIdentifier(expr)) {
+    if (import_ts_morph3.Node.isIdentifier(expr)) {
       this.processIdentifierCall(expr, sourceFile, handlerName, relationships, visited);
       return;
     }
-    if (import_ts_morph.Node.isPropertyAccessExpression(expr)) {
+    if (import_ts_morph3.Node.isPropertyAccessExpression(expr)) {
       const rel2 = this.extractFromPropertyAccess(expr, handlerName);
       if (rel2) {
         relationships.push(rel2);
@@ -235738,7 +236353,7 @@ class RelationshipExtractor {
     }
     let functionName = exprText;
     let targetComponent = null;
-    if (import_ts_morph.Node.isPropertyAccessExpression(expr)) {
+    if (import_ts_morph3.Node.isPropertyAccessExpression(expr)) {
       const objectExpr = expr.getExpression();
       const objectName = objectExpr.getText();
       const methodName = expr.getName();
@@ -235763,13 +236378,13 @@ class RelationshipExtractor {
     };
   }
   extractFromPropertyAccess(propAccess, handlerName) {
-    if (!import_ts_morph.Node.isPropertyAccessExpression(propAccess)) {
+    if (!import_ts_morph3.Node.isPropertyAccessExpression(propAccess)) {
       return null;
     }
     const fullChain = propAccess.getText();
     const methodName = propAccess.getName();
     let rootObject = propAccess.getExpression();
-    while (import_ts_morph.Node.isPropertyAccessExpression(rootObject)) {
+    while (import_ts_morph3.Node.isPropertyAccessExpression(rootObject)) {
       rootObject = rootObject.getExpression();
     }
     const objectName = rootObject.getText();
@@ -235787,11 +236402,11 @@ class RelationshipExtractor {
     };
   }
   extractFromDatabaseCall(awaitExpr, handlerName) {
-    if (!import_ts_morph.Node.isAwaitExpression(awaitExpr)) {
+    if (!import_ts_morph3.Node.isAwaitExpression(awaitExpr)) {
       return null;
     }
     const innerExpr = awaitExpr.getExpression();
-    if (!import_ts_morph.Node.isCallExpression(innerExpr)) {
+    if (!import_ts_morph3.Node.isCallExpression(innerExpr)) {
       return null;
     }
     const callExpr = innerExpr.getExpression().getText();
@@ -235975,7 +236590,7 @@ class RelationshipExtractor {
     const variableDecl = moduleSpecifier.getVariableDeclaration(functionName);
     if (variableDecl) {
       const initializer = variableDecl.getInitializer();
-      if (initializer && (import_ts_morph.Node.isArrowFunction(initializer) || import_ts_morph.Node.isFunctionExpression(initializer))) {
+      if (initializer && (import_ts_morph3.Node.isArrowFunction(initializer) || import_ts_morph3.Node.isFunctionExpression(initializer))) {
         return {
           functionDecl: initializer,
           sourceFile: moduleSpecifier
@@ -236009,9 +236624,9 @@ class RelationshipExtractor {
     return unique;
   }
 }
-var import_ts_morph;
+var import_ts_morph3;
 var init_relationships = __esm(() => {
-  import_ts_morph = __toESM(require_ts_morph(), 1);
+  import_ts_morph3 = __toESM(require_ts_morph(), 1);
 });
 
 // tools/analysis/src/extract/handlers.ts
@@ -236020,7 +236635,7 @@ class HandlerExtractor {
   typeGuardCache;
   relationshipExtractor;
   constructor(tsConfigPath) {
-    this.project = new import_ts_morph2.Project({
+    this.project = new import_ts_morph4.Project({
       tsConfigFilePath: tsConfigPath
     });
     this.typeGuardCache = new WeakMap;
@@ -236086,25 +236701,25 @@ class HandlerExtractor {
     return handlers;
   }
   processNodeForHandlers(node, context, filePath, handlers) {
-    if (import_ts_morph2.Node.isCallExpression(node)) {
+    if (import_ts_morph4.Node.isCallExpression(node)) {
       this.processCallExpressionHandler(node, context, filePath, handlers);
     }
-    if (import_ts_morph2.Node.isSwitchStatement(node)) {
+    if (import_ts_morph4.Node.isSwitchStatement(node)) {
       const switchHandlers = this.extractSwitchCaseHandlers(node, context, filePath);
       handlers.push(...switchHandlers);
     }
-    if (import_ts_morph2.Node.isVariableDeclaration(node)) {
+    if (import_ts_morph4.Node.isVariableDeclaration(node)) {
       const mapHandlers = this.extractHandlerMapPattern(node, context, filePath);
       handlers.push(...mapHandlers);
     }
-    if (import_ts_morph2.Node.isIfStatement(node) && !this.isElseIfStatement(node)) {
+    if (import_ts_morph4.Node.isIfStatement(node) && !this.isElseIfStatement(node)) {
       const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
       handlers.push(...typeGuardHandlers);
     }
   }
   processCallExpressionHandler(node, context, filePath, handlers) {
     const expression = node.getExpression();
-    if (import_ts_morph2.Node.isPropertyAccessExpression(expression)) {
+    if (import_ts_morph4.Node.isPropertyAccessExpression(expression)) {
       const methodName = expression.getName();
       if (methodName === "on" || methodName === "addEventListener") {
         const handler = this.extractHandler(node, context, filePath);
@@ -236116,7 +236731,7 @@ class HandlerExtractor {
   }
   isElseIfStatement(node) {
     const parent = node.getParent();
-    return parent !== undefined && import_ts_morph2.Node.isIfStatement(parent);
+    return parent !== undefined && import_ts_morph4.Node.isIfStatement(parent);
   }
   extractHandler(callExpr, context, filePath) {
     const args = callExpr.getArguments();
@@ -236125,9 +236740,9 @@ class HandlerExtractor {
     }
     const messageTypeArg = args[0];
     let messageType = null;
-    if (import_ts_morph2.Node.isStringLiteral(messageTypeArg)) {
+    if (import_ts_morph4.Node.isStringLiteral(messageTypeArg)) {
       messageType = messageTypeArg.getLiteralValue();
-    } else if (import_ts_morph2.Node.isTemplateExpression(messageTypeArg)) {
+    } else if (import_ts_morph4.Node.isTemplateExpression(messageTypeArg)) {
       messageType = messageTypeArg.getText().replace(/[`'"]/g, "");
     }
     if (!messageType) {
@@ -236137,7 +236752,7 @@ class HandlerExtractor {
     const assignments = [];
     const preconditions = [];
     const postconditions = [];
-    if (import_ts_morph2.Node.isArrowFunction(handlerArg) || import_ts_morph2.Node.isFunctionExpression(handlerArg)) {
+    if (import_ts_morph4.Node.isArrowFunction(handlerArg) || import_ts_morph4.Node.isFunctionExpression(handlerArg)) {
       this.extractAssignments(handlerArg, assignments);
       this.extractVerificationConditions(handlerArg, preconditions, postconditions);
       this.checkAsyncMutations(handlerArg, messageType);
@@ -236146,7 +236761,7 @@ class HandlerExtractor {
     const sourceFile = callExpr.getSourceFile();
     const handlerName = `${messageType}_handler`;
     let relationships;
-    if (import_ts_morph2.Node.isArrowFunction(handlerArg) || import_ts_morph2.Node.isFunctionExpression(handlerArg)) {
+    if (import_ts_morph4.Node.isArrowFunction(handlerArg) || import_ts_morph4.Node.isFunctionExpression(handlerArg)) {
       const detectedRelationships = this.relationshipExtractor.extractFromHandler(handlerArg, sourceFile, handlerName);
       if (detectedRelationships.length > 0) {
         relationships = detectedRelationships;
@@ -236167,16 +236782,16 @@ class HandlerExtractor {
   }
   extractAssignments(funcNode, assignments) {
     funcNode.forEachDescendant((node) => {
-      if (import_ts_morph2.Node.isBinaryExpression(node)) {
+      if (import_ts_morph4.Node.isBinaryExpression(node)) {
         this.extractBinaryExpressionAssignment(node, assignments);
       }
-      if (import_ts_morph2.Node.isCallExpression(node)) {
+      if (import_ts_morph4.Node.isCallExpression(node)) {
         this.extractArrayMutationAssignment(node, assignments);
       }
     });
   }
   extractBinaryExpressionAssignment(node, assignments) {
-    if (!import_ts_morph2.Node.isBinaryExpression(node))
+    if (!import_ts_morph4.Node.isBinaryExpression(node))
       return;
     const operator = node.getOperatorToken().getText();
     if (operator === "=") {
@@ -236186,18 +236801,18 @@ class HandlerExtractor {
     }
   }
   extractSimpleOrElementAccessAssignment(node, assignments) {
-    if (!import_ts_morph2.Node.isBinaryExpression(node))
+    if (!import_ts_morph4.Node.isBinaryExpression(node))
       return;
     const left = node.getLeft();
     const right = node.getRight();
-    if (import_ts_morph2.Node.isPropertyAccessExpression(left)) {
+    if (import_ts_morph4.Node.isPropertyAccessExpression(left)) {
       this.extractPropertyAccessAssignment(left, right, assignments);
-    } else if (import_ts_morph2.Node.isElementAccessExpression(left)) {
+    } else if (import_ts_morph4.Node.isElementAccessExpression(left)) {
       this.extractElementAccessAssignment(left, right, assignments);
     }
   }
   extractPropertyAccessAssignment(left, right, assignments) {
-    if (!import_ts_morph2.Node.isPropertyAccessExpression(left))
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(left))
       return;
     const fieldPath = this.getPropertyPath(left);
     if (fieldPath.startsWith("state.")) {
@@ -236209,10 +236824,10 @@ class HandlerExtractor {
     }
   }
   extractElementAccessAssignment(left, right, assignments) {
-    if (!import_ts_morph2.Node.isElementAccessExpression(left))
+    if (!import_ts_morph4.Node.isElementAccessExpression(left))
       return;
     const expr = left.getExpression();
-    if (!import_ts_morph2.Node.isPropertyAccessExpression(expr))
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expr))
       return;
     const fieldPath = this.getPropertyPath(expr);
     if (!fieldPath.startsWith("state."))
@@ -236222,7 +236837,7 @@ class HandlerExtractor {
     const index = indexExpr ? indexExpr.getText() : "0";
     const value = this.extractValue(right);
     if (value !== undefined) {
-      const tlaIndex = this.isNumericLiteral(index) ? (Number.parseInt(index) + 1).toString() : `${index} + 1`;
+      const tlaIndex = this.isNumericLiteral(index) ? (Number.parseInt(index, 10) + 1).toString() : `${index} + 1`;
       assignments.push({
         field: `${field}[${tlaIndex}]`,
         value
@@ -236230,12 +236845,12 @@ class HandlerExtractor {
     }
   }
   extractCompoundAssignment(node, assignments) {
-    if (!import_ts_morph2.Node.isBinaryExpression(node))
+    if (!import_ts_morph4.Node.isBinaryExpression(node))
       return;
     const operator = node.getOperatorToken().getText();
     const left = node.getLeft();
     const right = node.getRight();
-    if (import_ts_morph2.Node.isPropertyAccessExpression(left)) {
+    if (import_ts_morph4.Node.isPropertyAccessExpression(left)) {
       const fieldPath = this.getPropertyPath(left);
       if (fieldPath.startsWith("state.")) {
         const field = fieldPath.substring(6);
@@ -236249,14 +236864,14 @@ class HandlerExtractor {
     }
   }
   extractArrayMutationAssignment(node, assignments) {
-    if (!import_ts_morph2.Node.isCallExpression(node))
+    if (!import_ts_morph4.Node.isCallExpression(node))
       return;
     const expr = node.getExpression();
-    if (!import_ts_morph2.Node.isPropertyAccessExpression(expr))
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expr))
       return;
     const methodName = expr.getName();
     const object = expr.getExpression();
-    if (import_ts_morph2.Node.isPropertyAccessExpression(object)) {
+    if (import_ts_morph4.Node.isPropertyAccessExpression(object)) {
       const fieldPath = this.getPropertyPath(object);
       if (fieldPath.startsWith("state.")) {
         const field = fieldPath.substring(6);
@@ -236288,13 +236903,13 @@ class HandlerExtractor {
     }
   }
   checkAsyncMutations(funcNode, messageType) {
-    const isAsync = funcNode.hasModifier?.(import_ts_morph2.SyntaxKind.AsyncKeyword) || funcNode.getModifiers?.()?.some((m) => m.getKind() === import_ts_morph2.SyntaxKind.AsyncKeyword);
+    const isAsync = funcNode.hasModifier?.(import_ts_morph4.SyntaxKind.AsyncKeyword) || funcNode.getModifiers?.()?.some((m) => m.getKind() === import_ts_morph4.SyntaxKind.AsyncKeyword);
     if (!isAsync) {
       return;
     }
     const awaitExpressions = [];
     funcNode.forEachDescendant((node) => {
-      if (import_ts_morph2.Node.isAwaitExpression(node)) {
+      if (import_ts_morph4.Node.isAwaitExpression(node)) {
         awaitExpressions.push(node);
       }
     });
@@ -236308,10 +236923,10 @@ class HandlerExtractor {
     }
     const firstAwaitPos = awaitExpressions[0].getStart();
     funcNode.forEachDescendant((node) => {
-      if (import_ts_morph2.Node.isBinaryExpression(node)) {
+      if (import_ts_morph4.Node.isBinaryExpression(node)) {
         this.checkBinaryExpressionMutation(node, firstAwaitPos, mutations);
       }
-      if (import_ts_morph2.Node.isCallExpression(node)) {
+      if (import_ts_morph4.Node.isCallExpression(node)) {
         this.checkCallExpressionMutation(node, firstAwaitPos, mutations);
       }
     });
@@ -236324,19 +236939,19 @@ class HandlerExtractor {
   }
   extractVerificationConditions(funcNode, preconditions, postconditions) {
     const body = funcNode.getBody();
-    const statements = import_ts_morph2.Node.isBlock(body) ? body.getStatements() : [body];
+    const statements = import_ts_morph4.Node.isBlock(body) ? body.getStatements() : [body];
     for (const statement of statements) {
       this.processStatementForConditions(statement, preconditions, postconditions);
     }
   }
   processStatementForConditions(statement, preconditions, postconditions) {
-    if (!import_ts_morph2.Node.isExpressionStatement(statement))
+    if (!import_ts_morph4.Node.isExpressionStatement(statement))
       return;
     const expr = statement.getExpression();
-    if (!import_ts_morph2.Node.isCallExpression(expr))
+    if (!import_ts_morph4.Node.isCallExpression(expr))
       return;
     const callee = expr.getExpression();
-    if (!import_ts_morph2.Node.isIdentifier(callee))
+    if (!import_ts_morph4.Node.isIdentifier(callee))
       return;
     const functionName = callee.getText();
     if (functionName === "requires") {
@@ -236359,7 +236974,7 @@ class HandlerExtractor {
     const conditionArg = args[0];
     const expression = conditionArg.getText();
     let message;
-    if (args.length >= 2 && import_ts_morph2.Node.isStringLiteral(args[1])) {
+    if (args.length >= 2 && import_ts_morph4.Node.isStringLiteral(args[1])) {
       message = args[1].getLiteralValue();
     }
     const line = callExpr.getStartLineNumber();
@@ -236376,29 +236991,29 @@ class HandlerExtractor {
   getPropertyPath(node) {
     const parts = [];
     let current = node;
-    while (import_ts_morph2.Node.isPropertyAccessExpression(current)) {
+    while (import_ts_morph4.Node.isPropertyAccessExpression(current)) {
       parts.unshift(current.getName());
       current = current.getExpression();
     }
-    if (import_ts_morph2.Node.isIdentifier(current)) {
+    if (import_ts_morph4.Node.isIdentifier(current)) {
       parts.unshift(current.getText());
     }
     return parts.join(".");
   }
   extractValue(node) {
-    if (import_ts_morph2.Node.isStringLiteral(node)) {
+    if (import_ts_morph4.Node.isStringLiteral(node)) {
       return node.getLiteralValue();
     }
-    if (import_ts_morph2.Node.isNumericLiteral(node)) {
+    if (import_ts_morph4.Node.isNumericLiteral(node)) {
       return node.getLiteralValue();
     }
-    if (node.getKind() === import_ts_morph2.SyntaxKind.TrueKeyword) {
+    if (node.getKind() === import_ts_morph4.SyntaxKind.TrueKeyword) {
       return true;
     }
-    if (node.getKind() === import_ts_morph2.SyntaxKind.FalseKeyword) {
+    if (node.getKind() === import_ts_morph4.SyntaxKind.FalseKeyword) {
       return false;
     }
-    if (node.getKind() === import_ts_morph2.SyntaxKind.NullKeyword) {
+    if (node.getKind() === import_ts_morph4.SyntaxKind.NullKeyword) {
       return null;
     }
     return;
@@ -236416,10 +237031,10 @@ class HandlerExtractor {
       }
       const caseClauses = switchNode.getClauses();
       for (const clause of caseClauses) {
-        if (import_ts_morph2.Node.isCaseClause(clause)) {
+        if (import_ts_morph4.Node.isCaseClause(clause)) {
           const caseExpr = clause.getExpression();
           let messageType = null;
-          if (import_ts_morph2.Node.isStringLiteral(caseExpr)) {
+          if (import_ts_morph4.Node.isStringLiteral(caseExpr)) {
             messageType = caseExpr.getLiteralValue();
           }
           if (messageType) {
@@ -236456,14 +237071,14 @@ class HandlerExtractor {
     return handlers;
   }
   isHandlerMapInitializer(initializer, varDecl) {
-    if (!initializer || !import_ts_morph2.Node.isObjectLiteralExpression(initializer)) {
+    if (!initializer || !import_ts_morph4.Node.isObjectLiteralExpression(initializer)) {
       return false;
     }
     const varName = varDecl.getName().toLowerCase();
     return /(handler|listener|callback|event)s?/.test(varName);
   }
   extractHandlerFromProperty(prop, context, filePath) {
-    if (!import_ts_morph2.Node.isPropertyAssignment(prop)) {
+    if (!import_ts_morph4.Node.isPropertyAssignment(prop)) {
       return null;
     }
     const nameNode = prop.getNameNode();
@@ -236482,10 +237097,10 @@ class HandlerExtractor {
     };
   }
   getMessageTypeFromPropertyName(nameNode) {
-    if (import_ts_morph2.Node.isStringLiteral(nameNode)) {
+    if (import_ts_morph4.Node.isStringLiteral(nameNode)) {
       return nameNode.getLiteralValue();
     }
-    if (import_ts_morph2.Node.isIdentifier(nameNode)) {
+    if (import_ts_morph4.Node.isIdentifier(nameNode)) {
       return nameNode.getText();
     }
     return null;
@@ -236530,7 +237145,7 @@ class HandlerExtractor {
         this.debugLogFoundHandler(handler);
       }
       const elseStatement = ifStatement.getElseStatement();
-      if (elseStatement && import_ts_morph2.Node.isIfStatement(elseStatement)) {
+      if (elseStatement && import_ts_morph4.Node.isIfStatement(elseStatement)) {
         ifStatement = elseStatement;
       } else {
         break;
@@ -236551,11 +237166,11 @@ class HandlerExtractor {
     try {
       const ifStmt = ifNode;
       const condition = ifStmt.getExpression();
-      if (!import_ts_morph2.Node.isCallExpression(condition)) {
+      if (!import_ts_morph4.Node.isCallExpression(condition)) {
         return null;
       }
       const funcExpr = condition.getExpression();
-      const funcName = import_ts_morph2.Node.isIdentifier(funcExpr) ? funcExpr.getText() : undefined;
+      const funcName = import_ts_morph4.Node.isIdentifier(funcExpr) ? funcExpr.getText() : undefined;
       this.debugLogProcessingFunction(funcName);
       const messageType = this.resolveMessageType(funcExpr, funcName, typeGuards);
       if (!messageType) {
@@ -236595,7 +237210,7 @@ class HandlerExtractor {
         return guardType;
       }
     }
-    if (import_ts_morph2.Node.isIdentifier(funcExpr)) {
+    if (import_ts_morph4.Node.isIdentifier(funcExpr)) {
       this.debugLogTryingImportResolution(funcName);
       return this.resolveImportedTypeGuard(funcExpr) ?? undefined;
     }
@@ -236633,7 +237248,7 @@ class HandlerExtractor {
       return;
     }
     const returnTypeNode = node.getReturnTypeNode();
-    if (!returnTypeNode || !import_ts_morph2.Node.isTypePredicate(returnTypeNode)) {
+    if (!returnTypeNode || !import_ts_morph4.Node.isTypePredicate(returnTypeNode)) {
       return;
     }
     const functionName = this.extractFunctionName(node);
@@ -236646,17 +237261,17 @@ class HandlerExtractor {
     }
   }
   extractFunctionName(node) {
-    if (import_ts_morph2.Node.isFunctionDeclaration(node)) {
+    if (import_ts_morph4.Node.isFunctionDeclaration(node)) {
       return node.getName();
     }
-    if (import_ts_morph2.Node.isFunctionExpression(node) || import_ts_morph2.Node.isArrowFunction(node)) {
+    if (import_ts_morph4.Node.isFunctionExpression(node) || import_ts_morph4.Node.isArrowFunction(node)) {
       return this.extractFunctionNameFromVariable(node);
     }
     return;
   }
   extractFunctionNameFromVariable(node) {
     const parent = node.getParent();
-    if (import_ts_morph2.Node.isVariableDeclaration(parent)) {
+    if (import_ts_morph4.Node.isVariableDeclaration(parent)) {
       return parent.getName();
     }
     return;
@@ -236716,10 +237331,10 @@ class HandlerExtractor {
     return this.extractFromFunctionBody(def, funcName);
   }
   isFunctionNode(node) {
-    return import_ts_morph2.Node.isFunctionDeclaration(node) || import_ts_morph2.Node.isFunctionExpression(node) || import_ts_morph2.Node.isArrowFunction(node);
+    return import_ts_morph4.Node.isFunctionDeclaration(node) || import_ts_morph4.Node.isFunctionExpression(node) || import_ts_morph4.Node.isArrowFunction(node);
   }
   extractFromTypePredicate(returnTypeNode, funcName) {
-    if (!returnTypeNode || !import_ts_morph2.Node.isTypePredicate(returnTypeNode)) {
+    if (!returnTypeNode || !import_ts_morph4.Node.isTypePredicate(returnTypeNode)) {
       return null;
     }
     const typeNode = returnTypeNode.getTypeNode();
@@ -236758,7 +237373,7 @@ class HandlerExtractor {
       const returnType = def.getReturnType().getText();
       console.log(`[DEBUG] Function ${funcName} return type (resolved): ${returnType}`);
       console.log(`[DEBUG] Has return type node: ${!!returnTypeNode}`);
-      console.log(`[DEBUG] Is type predicate node: ${returnTypeNode && import_ts_morph2.Node.isTypePredicate(returnTypeNode)}`);
+      console.log(`[DEBUG] Is type predicate node: ${returnTypeNode && import_ts_morph4.Node.isTypePredicate(returnTypeNode)}`);
     }
   }
   debugLogTypePredicateResolution(funcName, messageType) {
@@ -236836,15 +237451,15 @@ class HandlerExtractor {
     return null;
   }
   checkBinaryExpressionMutation(node, firstAwaitPos, mutations) {
-    if (!import_ts_morph2.Node.isBinaryExpression(node))
+    if (!import_ts_morph4.Node.isBinaryExpression(node))
       return;
     const operator = node.getOperatorToken().getText();
     if (operator !== "=" && !["+=", "-=", "*=", "/=", "%="].includes(operator))
       return;
     const left = node.getLeft();
-    if (!import_ts_morph2.Node.isPropertyAccessExpression(left) && !import_ts_morph2.Node.isElementAccessExpression(left))
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(left) && !import_ts_morph4.Node.isElementAccessExpression(left))
       return;
-    const fieldPath = import_ts_morph2.Node.isPropertyAccessExpression(left) ? this.getPropertyPath(left) : this.getPropertyPath(left.getExpression());
+    const fieldPath = import_ts_morph4.Node.isPropertyAccessExpression(left) ? this.getPropertyPath(left) : this.getPropertyPath(left.getExpression());
     if (fieldPath.startsWith("state.")) {
       const field = fieldPath.substring(6);
       const line = node.getStartLineNumber();
@@ -236853,14 +237468,14 @@ class HandlerExtractor {
     }
   }
   checkCallExpressionMutation(node, firstAwaitPos, mutations) {
-    if (!import_ts_morph2.Node.isCallExpression(node))
+    if (!import_ts_morph4.Node.isCallExpression(node))
       return;
     const expr = node.getExpression();
-    if (!import_ts_morph2.Node.isPropertyAccessExpression(expr))
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expr))
       return;
     const methodName = expr.getName();
     const object = expr.getExpression();
-    if (!import_ts_morph2.Node.isPropertyAccessExpression(object))
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(object))
       return;
     const fieldPath = this.getPropertyPath(object);
     if (!fieldPath.startsWith("state."))
@@ -236877,442 +237492,252 @@ function extractHandlers(tsConfigPath) {
   const extractor = new HandlerExtractor(tsConfigPath);
   return extractor.extractHandlers();
 }
-var import_ts_morph2;
+var import_ts_morph4;
 var init_handlers = __esm(() => {
   init_relationships();
-  import_ts_morph2 = __toESM(require_ts_morph(), 1);
+  import_ts_morph4 = __toESM(require_ts_morph(), 1);
 });
 
-// tools/analysis/src/extract/types.ts
-class TypeExtractor {
+// tools/analysis/src/extract/integrations.ts
+class IntegrationAnalyzer {
   project;
   constructor(tsConfigPath) {
-    this.project = new import_ts_morph3.Project({
+    this.project = new import_ts_morph5.Project({
       tsConfigFilePath: tsConfigPath
     });
   }
-  async analyzeCodebase(stateFilePath) {
-    const stateType = stateFilePath ? this.extractStateType(stateFilePath) : this.findStateType();
-    const messageTypes = this.findMessageTypes();
-    const fields = stateType ? this.analyzeFields(stateType) : [];
-    const handlerAnalysis = this.extractHandlerAnalysis();
-    const validMessageTypes = this.filterAndLogMessageTypes(messageTypes, handlerAnalysis.messageTypes);
-    const validHandlers = this.filterAndLogHandlers(handlerAnalysis.handlers);
-    return {
-      stateType,
-      messageTypes: validMessageTypes,
-      fields,
-      handlers: validHandlers
-    };
-  }
-  extractHandlerAnalysis() {
-    const configFilePath = this.project.getCompilerOptions()["configFilePath"];
-    const tsConfigPath = typeof configFilePath === "string" ? configFilePath : "tsconfig.json";
-    const handlerExtractor = new HandlerExtractor(tsConfigPath);
-    return handlerExtractor.extractHandlers();
-  }
-  filterAndLogMessageTypes(messageTypes, handlerMessageTypes) {
-    const allMessageTypes = Array.from(new Set([...messageTypes, ...handlerMessageTypes]));
-    const validMessageTypes = [];
-    const invalidMessageTypes = [];
-    for (const msgType of allMessageTypes) {
-      if (this.isValidTLAIdentifier(msgType)) {
-        validMessageTypes.push(msgType);
-      } else {
-        invalidMessageTypes.push(msgType);
-      }
+  analyzeIntegrations() {
+    const integrations = new Map;
+    const fetchCalls = this.findFetchCalls();
+    for (const call of fetchCalls) {
+      this.addOrMergeIntegration(integrations, this.createAPIIntegration(call));
     }
-    this.logInvalidMessageTypes(invalidMessageTypes);
-    return validMessageTypes;
-  }
-  logInvalidMessageTypes(invalidMessageTypes) {
-    if (invalidMessageTypes.length === 0 || !process.env["POLLY_DEBUG"])
-      return;
-    console.log(`[WARN] Filtered out ${invalidMessageTypes.length} invalid message type(s):`);
-    for (const invalid of invalidMessageTypes) {
-      console.log(`[WARN]   - "${invalid}" (not a valid TLA+ identifier)`);
+    const websockets = this.findWebSockets();
+    for (const ws of websockets) {
+      this.addOrMergeIntegration(integrations, this.createWebSocketIntegration(ws));
     }
-  }
-  filterAndLogHandlers(handlers) {
-    const validHandlers = handlers.filter((h) => this.isValidTLAIdentifier(h.messageType));
-    this.logInvalidHandlers(handlers, validHandlers);
-    return validHandlers;
-  }
-  logInvalidHandlers(allHandlers, validHandlers) {
-    const filteredHandlerCount = allHandlers.length - validHandlers.length;
-    if (filteredHandlerCount === 0 || !process.env["POLLY_DEBUG"])
-      return;
-    console.log(`[WARN] Filtered out ${filteredHandlerCount} handler(s) with invalid message types:`);
-    for (const handler of allHandlers) {
-      if (!this.isValidTLAIdentifier(handler.messageType)) {
-        console.log(`[WARN]   - Handler for "${handler.messageType}" at ${handler.location.file}:${handler.location.line}`);
-      }
+    const externalScripts = this.findExternalScripts();
+    for (const script of externalScripts) {
+      this.addOrMergeIntegration(integrations, script);
     }
+    return Array.from(integrations.values());
   }
-  isValidTLAIdentifier(s) {
-    if (!s || s.length === 0) {
-      return false;
+  findFetchCalls() {
+    const calls = [];
+    for (const sourceFile of this.project.getSourceFiles()) {
+      sourceFile.forEachDescendant((node) => {
+        this.processFetchCall(node, sourceFile, calls);
+      });
     }
-    return /^[a-zA-Z][a-zA-Z0-9_]*$/.test(s);
+    return calls;
   }
-  extractStateType(filePath) {
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (!sourceFile) {
-      return null;
-    }
-    const typeAlias = sourceFile.getTypeAlias("AppState") || sourceFile.getTypeAlias("State") || sourceFile.getTypeAliases()[0];
-    if (!typeAlias) {
-      return null;
+  processFetchCall(node, sourceFile, calls) {
+    if (!import_ts_morph5.Node.isCallExpression(node)) {
+      return;
     }
-    const type2 = typeAlias.getType();
-    return this.convertType(type2, typeAlias.getName());
-  }
-  findStateType() {
-    const stateFiles = this.project.getSourceFiles("**/state*.ts");
-    for (const file of stateFiles) {
-      const typeAlias = file.getTypeAlias("AppState") || file.getTypeAlias("State");
-      if (typeAlias) {
-        const type2 = typeAlias.getType();
-        return this.convertType(type2, typeAlias.getName());
-      }
+    const expression = node.getExpression();
+    if (!this.isFetchCall(expression)) {
+      return;
     }
-    return null;
-  }
-  findMessageTypes() {
-    const messageTypes = [];
-    const warnings = [];
-    const messageFiles = this.project.getSourceFiles("**/message*.ts");
-    for (const file of messageFiles) {
-      for (const typeAlias of file.getTypeAliases()) {
-        const extractedTypes = this.extractMessageTypesFromType(typeAlias.getType(), typeAlias.getName(), file, warnings);
-        messageTypes.push(...extractedTypes);
-      }
+    const args = node.getArguments();
+    if (args.length === 0) {
+      return;
     }
-    if (warnings.length > 0 && process.env["POLLY_DEBUG"]) {
-      console.log("[WARN] Message type extraction warnings:");
-      for (const warning of warnings) {
-        console.log(`[WARN]   ${warning}`);
-      }
+    const url = this.extractURLFromArg(args[0]);
+    if (!url) {
+      return;
     }
-    return [...new Set(messageTypes)];
+    const method = this.extractMethodFromOptions(args);
+    const description = this.extractJSDocDescription(node);
+    calls.push({
+      url,
+      method,
+      file: sourceFile.getFilePath(),
+      line: node.getStartLineNumber(),
+      description
+    });
   }
-  extractMessageTypesFromType(type2, typeName, sourceFile, warnings) {
-    if (type2.isUnion()) {
-      return this.extractFromUnionType(type2, typeName, sourceFile, warnings);
-    }
-    if (type2.getAliasSymbol()) {
-      return this.extractFromTypeAlias(type2, typeName, sourceFile, warnings);
-    }
-    if (type2.isConditionalType?.()) {
-      return this.extractFromConditionalType(type2, warnings);
-    }
-    if (type2.getText().includes("[K in ")) {
-      return this.extractFromMappedType(type2, sourceFile, warnings);
+  isFetchCall(expression) {
+    return import_ts_morph5.Node.isIdentifier(expression) && expression.getText() === "fetch";
+  }
+  extractURLFromArg(urlArg) {
+    if (import_ts_morph5.Node.isStringLiteral(urlArg)) {
+      return urlArg.getLiteralValue();
     }
-    if (type2.getText().includes("`")) {
-      this.warnTemplateLiteral(type2, warnings);
-      return [];
+    if (import_ts_morph5.Node.isTemplateExpression(urlArg)) {
+      return this.extractBaseURL(urlArg.getText());
     }
-    return [];
+    return null;
   }
-  extractFromUnionType(type2, typeName, sourceFile, warnings) {
-    const messageTypes = [];
-    const unionTypes = type2.getUnionTypes();
-    for (const unionType of unionTypes) {
-      const extracted = this.extractFromUnionMember(unionType, typeName, sourceFile, warnings);
-      messageTypes.push(...extracted);
+  extractMethodFromOptions(args) {
+    const defaultMethod = "GET";
+    if (args.length <= 1) {
+      return defaultMethod;
     }
-    return messageTypes;
-  }
-  extractFromUnionMember(unionType, typeName, sourceFile, warnings) {
-    if (unionType.isObject()) {
-      return this.extractFromDiscriminatedUnion(unionType, sourceFile, warnings);
+    const optionsArg = args[1];
+    if (!import_ts_morph5.Node.isObjectLiteralExpression(optionsArg)) {
+      return defaultMethod;
     }
-    if (unionType.isStringLiteral()) {
-      return [unionType.getLiteralValue()];
+    const methodProp = optionsArg.getProperty("method");
+    if (!methodProp || !import_ts_morph5.Node.isPropertyAssignment(methodProp)) {
+      return defaultMethod;
     }
-    if (unionType.getAliasSymbol()) {
-      const aliasedType = unionType.getAliasSymbol()?.getDeclaredType();
-      if (aliasedType) {
-        return this.extractMessageTypesFromType(aliasedType, typeName, sourceFile, warnings);
-      }
+    const initializer = methodProp.getInitializer();
+    if (!initializer || !import_ts_morph5.Node.isStringLiteral(initializer)) {
+      return defaultMethod;
     }
-    return [];
+    return initializer.getLiteralValue().toUpperCase();
   }
-  extractFromDiscriminatedUnion(unionType, sourceFile, warnings) {
-    const typeProperty = unionType.getProperty("type");
-    if (!typeProperty) {
-      return [];
-    }
-    const typeType = typeProperty.getTypeAtLocation(sourceFile);
-    if (typeType.isStringLiteral()) {
-      return [typeType.getLiteralValue()];
-    }
-    if (typeType.getText().includes("`")) {
-      warnings.push(`Template literal type in discriminant: ${typeType.getText()} - may be unbounded`);
+  findWebSockets() {
+    const websockets = [];
+    for (const sourceFile of this.project.getSourceFiles()) {
+      sourceFile.forEachDescendant((node) => {
+        if (import_ts_morph5.Node.isNewExpression(node)) {
+          const expression = node.getExpression();
+          if (import_ts_morph5.Node.isIdentifier(expression) && expression.getText() === "WebSocket") {
+            const args = node.getArguments();
+            if (args.length > 0 && import_ts_morph5.Node.isStringLiteral(args[0])) {
+              const url = args[0].getLiteralValue();
+              const description = this.extractJSDocDescription(node);
+              websockets.push({
+                url,
+                file: sourceFile.getFilePath(),
+                line: node.getStartLineNumber(),
+                description
+              });
+            }
+          }
+        }
+      });
     }
-    return [];
+    return websockets;
   }
-  extractFromTypeAlias(type2, typeName, sourceFile, warnings) {
-    const aliasedType = type2.getAliasSymbol()?.getDeclaredType();
-    if (!aliasedType || aliasedType === type2) {
-      return [];
+  findExternalScripts() {
+    const scripts = [];
+    const seen = new Set;
+    for (const sourceFile of this.project.getSourceFiles()) {
+      this.extractExternalImportsFromFile(sourceFile, scripts, seen);
     }
-    return this.extractMessageTypesFromType(aliasedType, typeName, sourceFile, warnings);
+    return scripts;
   }
-  extractFromConditionalType(type2, warnings) {
-    warnings.push(`Conditional type detected: ${type2.getText()} - extracting conservatively`);
-    const messageTypes = [];
-    const typeText = type2.getText();
-    const parts = typeText.split("?");
-    if (parts.length < 2) {
-      return messageTypes;
-    }
-    const branches = parts[1].split(":");
-    for (const branch of branches) {
-      const extracted = this.extractStringLiteralFromBranch(branch);
-      if (extracted) {
-        messageTypes.push(extracted);
+  extractExternalImportsFromFile(sourceFile, scripts, seen) {
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = importDecl.getModuleSpecifierValue();
+      if (this.isExternalImport(moduleSpecifier)) {
+        const packageName = this.extractPackageName(moduleSpecifier);
+        if (packageName && !seen.has(packageName)) {
+          seen.add(packageName);
+          scripts.push(this.createExternalScriptIntegration(packageName, sourceFile));
+        }
       }
     }
-    return messageTypes;
   }
-  extractStringLiteralFromBranch(branch) {
-    const trimmed = branch.trim();
-    const match = trimmed.match(/^["'](\w+)["']$/);
-    return match?.[1] ?? null;
+  isExternalImport(moduleSpecifier) {
+    return !moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/");
   }
-  extractFromMappedType(type2, sourceFile, warnings) {
-    warnings.push(`Mapped type detected: ${type2.getText()} - attempting to extract keys`);
-    const match = type2.getText().match(/\[K in ([^\]]+)\]/);
-    if (!match?.[1]) {
-      return [];
-    }
-    const keyTypeName = match[1].trim();
-    const keyTypeAlias = sourceFile.getTypeAlias?.(keyTypeName);
-    if (!keyTypeAlias) {
-      return [];
+  extractPackageName(moduleSpecifier) {
+    if (moduleSpecifier.startsWith("@")) {
+      return moduleSpecifier.split("/").slice(0, 2).join("/");
     }
-    const keyType = keyTypeAlias.getType();
-    return this.extractMessageTypesFromType(keyType, keyTypeName, sourceFile, warnings);
-  }
-  warnTemplateLiteral(type2, warnings) {
-    warnings.push(`Template literal type: ${type2.getText()} - this creates an unbounded set and cannot be fully extracted`);
+    return moduleSpecifier.split("/")[0];
   }
-  convertType(type2, name) {
-    const nullable = type2.isNullable();
-    if (type2.isBoolean() || type2.isBooleanLiteral()) {
-      return { name, kind: "boolean", nullable };
-    }
-    if (type2.isUnion()) {
-      return this.convertUnionType(type2, name, nullable);
-    }
-    if (type2.isString() || type2.isStringLiteral()) {
-      return { name, kind: "string", nullable };
-    }
-    if (type2.isNumber() || type2.isNumberLiteral()) {
-      return { name, kind: "number", nullable };
-    }
-    if (type2.isArray()) {
-      return this.convertArrayType(type2, name, nullable);
-    }
-    const collectionType = this.tryConvertCollectionType(type2, name, nullable);
-    if (collectionType) {
-      return collectionType;
-    }
-    if (type2.isObject()) {
-      return this.convertObjectType(type2, name, nullable);
-    }
-    if (type2.isNull()) {
-      return { name, kind: "null", nullable: true };
-    }
-    return { name, kind: "unknown", nullable };
+  createExternalScriptIntegration(packageName, sourceFile) {
+    return {
+      type: "external-script",
+      name: packageName,
+      technology: "npm package",
+      usedIn: [sourceFile.getFilePath()],
+      description: `External dependency: ${packageName}`
+    };
   }
-  convertUnionType(type2, name, nullable) {
-    const unionTypes = type2.getUnionTypes();
-    const allStringLiterals = unionTypes.every((t) => t.isStringLiteral());
-    if (allStringLiterals) {
-      const enumValues = unionTypes.map((t) => t.getLiteralValue());
-      return { name, kind: "enum", nullable, enumValues };
-    }
-    const nonNullTypes = unionTypes.filter((t) => !t.isNull() && !t.isUndefined());
-    if (nonNullTypes.length === 1) {
-      const firstType = nonNullTypes[0];
-      if (firstType) {
-        const baseType = this.convertType(firstType, name);
-        return { ...baseType, nullable: true };
-      }
-    }
+  createAPIIntegration(call) {
+    const baseURL = this.extractBaseURL(call.url);
+    const name = this.inferAPIName(baseURL);
     return {
+      type: "api",
       name,
-      kind: "union",
-      nullable,
-      unionTypes: unionTypes.map((t, i2) => this.convertType(t, `${name}_${i2}`))
+      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
+        }
+      ]
     };
   }
-  convertArrayType(type2, name, nullable) {
-    const elementType = type2.getArrayElementType();
+  createWebSocketIntegration(ws) {
+    const name = this.inferAPIName(ws.url);
     return {
+      type: "websocket",
       name,
-      kind: "array",
-      nullable,
-      elementType: elementType ? this.convertType(elementType, `${name}_element`) : { name: "unknown", kind: "unknown", nullable: false }
+      technology: "WebSocket",
+      url: ws.url,
+      usedIn: [ws.file],
+      description: ws.description || `WebSocket connection: ${name}`
     };
   }
-  tryConvertCollectionType(type2, name, nullable) {
-    const symbol = type2.getSymbol();
-    if (!symbol)
-      return null;
-    const symbolName = symbol.getName();
-    if (symbolName === "Map") {
-      const typeArgs = type2.getTypeArguments();
-      return {
-        name,
-        kind: "map",
-        nullable,
-        valueType: typeArgs?.[1] ? this.convertType(typeArgs[1], `${name}_value`) : undefined
-      };
-    }
-    if (symbolName === "Set") {
-      const typeArgs = type2.getTypeArguments();
-      return {
-        name,
-        kind: "set",
-        nullable,
-        elementType: typeArgs?.[0] ? this.convertType(typeArgs[0], `${name}_element`) : undefined
-      };
-    }
-    return null;
-  }
-  convertObjectType(type2, name, nullable) {
-    const properties = {};
-    const sourceFile = this.project.getSourceFiles()[0];
-    if (sourceFile) {
-      for (const prop of type2.getProperties()) {
-        const propName = prop.getName();
-        const propType = prop.getTypeAtLocation(sourceFile);
-        properties[propName] = this.convertType(propType, propName);
-      }
+  extractBaseURL(url) {
+    let cleanUrl = url.replace(/\$\{[^}]+\}/g, "");
+    cleanUrl = cleanUrl.replace(/`/g, "");
+    try {
+      const parsed = new URL(cleanUrl);
+      return `${parsed.protocol}//${parsed.host}`;
+    } catch {
+      const match = cleanUrl.match(/https?:\/\/([^/]+)/);
+      return match ? match[0] : cleanUrl;
     }
-    return { name, kind: "object", nullable, properties };
   }
-  analyzeFields(stateType, prefix = "") {
-    const fields = [];
-    if (stateType.kind === "object" && stateType.properties) {
-      for (const [key, propType] of Object.entries(stateType.properties)) {
-        const path = prefix ? `${prefix}.${key}` : key;
-        if (propType.kind === "object") {
-          fields.push(...this.analyzeFields(propType, path));
-        } else {
-          const analysis = this.analyzeField(path, propType);
-          fields.push(analysis);
-        }
+  inferAPIName(url) {
+    try {
+      const parsed = new URL(url);
+      const hostname2 = parsed.hostname;
+      const cleanHost = hostname2.replace(/^www\./, "");
+      const parts = cleanHost.split(".");
+      if (parts.length > 0 && parts[0]) {
+        return `${parts[0].charAt(0).toUpperCase() + parts[0].slice(1)} API`;
       }
-    }
-    return fields;
-  }
-  analyzeField(path, type2) {
-    const analysis = {
-      path,
-      type: type2,
-      confidence: "low",
-      evidence: [],
-      suggestions: [],
-      bounds: {}
-    };
-    if (type2.kind === "boolean")
-      return this.analyzeBooleanField(analysis);
-    if (type2.kind === "enum")
-      return this.analyzeEnumField(analysis, type2);
-    if (type2.kind === "array")
-      return this.analyzeArrayField(analysis);
-    if (type2.kind === "number")
-      return this.analyzeNumberField(analysis);
-    if (type2.kind === "string")
-      return this.analyzeStringField(analysis);
-    if (type2.kind === "map" || type2.kind === "set")
-      return this.analyzeMapSetField(analysis);
-    return analysis;
-  }
-  analyzeBooleanField(analysis) {
-    analysis.confidence = "high";
-    analysis.evidence.push("Boolean type - auto-configured");
-    return analysis;
+    } catch {}
+    return "External API";
   }
-  analyzeEnumField(analysis, type2) {
-    if (type2.enumValues) {
-      analysis.confidence = "high";
-      analysis.evidence.push(`Enum with ${type2.enumValues.length} values`);
-      if (analysis.bounds) {
-        analysis.bounds.values = type2.enumValues;
+  addOrMergeIntegration(map, integration) {
+    const key = `${integration.type}:${integration.name}`;
+    if (map.has(key)) {
+      const existing = map.get(key);
+      if (!existing)
+        return;
+      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);
     }
-    return analysis;
-  }
-  analyzeArrayField(analysis) {
-    analysis.confidence = "low";
-    analysis.suggestions.push("Choose maxLength: 5 (fast), 10 (balanced), or 20 (thorough)");
-    if (analysis.bounds) {
-      analysis.bounds.maxLength = undefined;
-    }
-    const foundBound = this.findArrayBound();
-    if (foundBound && analysis.bounds) {
-      analysis.confidence = "medium";
-      analysis.evidence.push(`Found array check: ${foundBound.evidence}`);
-      analysis.bounds.maxLength = foundBound.value;
-    }
-    return analysis;
-  }
-  analyzeNumberField(analysis) {
-    analysis.confidence = "low";
-    analysis.suggestions.push("Provide min and max values based on your application logic");
-    if (analysis.bounds) {
-      analysis.bounds.min = undefined;
-      analysis.bounds.max = undefined;
-    }
-    const foundBound = this.findNumberBound();
-    if (foundBound && analysis.bounds) {
-      analysis.confidence = "high";
-      analysis.evidence.push(`Found comparison: ${foundBound.evidence}`);
-      analysis.bounds = { ...analysis.bounds, ...foundBound.bounds };
-    }
-    return analysis;
-  }
-  analyzeStringField(analysis) {
-    analysis.confidence = "low";
-    analysis.suggestions.push('Provide 2-3 example values: ["value1", "value2", "value3"]', "Or use { abstract: true } for symbolic verification");
-    if (analysis.bounds) {
-      analysis.bounds.values = undefined;
-    }
-    return analysis;
-  }
-  analyzeMapSetField(analysis) {
-    analysis.confidence = "low";
-    analysis.suggestions.push("Provide maxSize (recommended: 3-5)");
-    if (analysis.bounds) {
-      analysis.bounds.maxSize = undefined;
-    }
-    return analysis;
   }
-  findArrayBound() {
-    return null;
-  }
-  findNumberBound() {
-    return null;
+  extractJSDocDescription(node) {
+    const jsDocs = node.getJsDocs?.() || [];
+    if (jsDocs.length === 0)
+      return;
+    const comment = jsDocs[0].getDescription().trim();
+    return comment || undefined;
   }
 }
-async function analyzeCodebase(options) {
-  const extractor = new TypeExtractor(options.tsConfigPath);
-  return extractor.analyzeCodebase(options.stateFilePath);
-}
-var import_ts_morph3;
-var init_types2 = __esm(() => {
-  init_handlers();
-  import_ts_morph3 = __toESM(require_ts_morph(), 1);
+var import_ts_morph5;
+var init_integrations = __esm(() => {
+  import_ts_morph5 = __toESM(require_ts_morph(), 1);
 });
 
 // tools/analysis/src/extract/manifest.ts
-var fs = (() => ({}));
+var fs2 = (() => ({}));
 
 class ManifestParser {
   manifestPath;
@@ -237321,7 +237746,7 @@ class ManifestParser {
   constructor(projectRoot, optional = false) {
     this.baseDir = projectRoot;
     this.manifestPath = join(projectRoot, "manifest.json");
-    if (!fs.existsSync(this.manifestPath)) {
+    if (!fs2.existsSync(this.manifestPath)) {
       if (optional) {
         this.manifestData = null;
         return;
@@ -237329,7 +237754,7 @@ class ManifestParser {
       throw new Error(`manifest.json not found at ${this.manifestPath}`);
     }
     try {
-      const content = fs.readFileSync(this.manifestPath, "utf-8");
+      const content = fs2.readFileSync(this.manifestPath, "utf-8");
       this.manifestData = JSON.parse(content);
     } catch (error) {
       throw new Error(`Failed to parse manifest.json: ${error}`);
@@ -237505,27 +237930,27 @@ class ManifestParser {
       join(this.baseDir, "src", manifestPath.replace(/\.js$/, ".tsx"))
     ];
     for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs2.existsSync(candidate)) {
         return candidate;
       }
     }
     return join(this.baseDir, manifestPath);
   }
   findAssociatedJS(htmlPath) {
-    if (!fs.existsSync(htmlPath)) {
+    if (!fs2.existsSync(htmlPath)) {
       return null;
     }
-    const html = fs.readFileSync(htmlPath, "utf-8");
+    const html = fs2.readFileSync(htmlPath, "utf-8");
     const scriptMatch = html.match(/<script[^>]+src=["']([^"']+)["']/i);
     if (scriptMatch?.[1]) {
       const scriptPath = scriptMatch[1];
       const fullPath = resolve(dirname(htmlPath), scriptPath);
-      if (fs.existsSync(fullPath))
+      if (fs2.existsSync(fullPath))
         return fullPath;
-      if (fs.existsSync(fullPath.replace(/\.js$/, ".ts"))) {
+      if (fs2.existsSync(fullPath.replace(/\.js$/, ".ts"))) {
         return fullPath.replace(/\.js$/, ".ts");
       }
-      if (fs.existsSync(fullPath.replace(/\.js$/, ".tsx"))) {
+      if (fs2.existsSync(fullPath.replace(/\.js$/, ".tsx"))) {
         return fullPath.replace(/\.js$/, ".tsx");
       }
     }
@@ -237540,7 +237965,7 @@ class ManifestParser {
       join(dir, "index.js")
     ];
     for (const candidate of candidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs2.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -237559,861 +237984,6 @@ var init_manifest = __esm(() => {
   init_path();
 });
 
-// tools/analysis/src/extract/contexts.ts
-class ContextAnalyzer {
-  project;
-  constructor(tsConfigPath) {
-    this.project = new import_ts_morph4.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 ? { components } : {},
-      dependencies,
-      ...description ? { description } : {}
-    };
-  }
-  extractChromeAPIs(sourceFile) {
-    const apis = new Set;
-    sourceFile.forEachDescendant((node) => {
-      if (import_ts_morph4.Node.isPropertyAccessExpression(node)) {
-        const text = node.getText();
-        this.detectAPIPattern(text, apis);
-      }
-    });
-    return Array.from(apis).sort();
-  }
-  detectAPIPattern(text, apis) {
-    if (text.startsWith("chrome.")) {
-      const api = this.extractAPIFromPrefix(text, "chrome");
-      if (api)
-        apis.add(api);
-      return;
-    }
-    if (text.startsWith("browser.")) {
-      const api = this.extractAPIFromPrefix(text, "browser");
-      if (api)
-        apis.add(api);
-      return;
-    }
-    if (text.includes("bus.adapters.")) {
-      const api = this.extractAPIFromBusAdapter(text);
-      if (api)
-        apis.add(api);
-    }
-  }
-  extractAPIFromPrefix(text, prefix) {
-    const pattern = new RegExp(`^${prefix}\\.([^.(]+(?:\\.[^.(]+)?)`);
-    const match = text.match(pattern);
-    return match?.[1] || null;
-  }
-  extractAPIFromBusAdapter(text) {
-    const match = text.match(/bus\.adapters\.([^.(]+)/);
-    return match?.[1] || null;
-  }
-  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) => {
-      this.extractFunctionComponent(node, sourceFile, components);
-      this.extractArrowFunctionComponent(node, sourceFile, components);
-      this.extractClassComponent(node, sourceFile, components);
-    });
-    return components;
-  }
-  extractFunctionComponent(node, sourceFile, components) {
-    if (!import_ts_morph4.Node.isFunctionDeclaration(node))
-      return;
-    const name = node.getName();
-    if (!name || !this.looksLikeComponent(name, node))
-      return;
-    const description = this.extractJSDocDescription(node);
-    components.push({
-      name,
-      type: "function",
-      filePath: sourceFile.getFilePath(),
-      line: node.getStartLineNumber(),
-      props: this.extractProps(node),
-      ...description ? { description } : {}
-    });
-  }
-  extractArrowFunctionComponent(node, sourceFile, components) {
-    if (!import_ts_morph4.Node.isVariableDeclaration(node))
-      return;
-    const name = node.getName();
-    const initializer = node.getInitializer();
-    if (!name || !initializer)
-      return;
-    if (!import_ts_morph4.Node.isArrowFunction(initializer) && !import_ts_morph4.Node.isFunctionExpression(initializer))
-      return;
-    if (!this.looksLikeComponent(name, initializer))
-      return;
-    const description = this.extractJSDocDescription(node);
-    components.push({
-      name,
-      type: "function",
-      filePath: sourceFile.getFilePath(),
-      line: node.getStartLineNumber(),
-      props: this.extractProps(initializer),
-      ...description ? { description } : {}
-    });
-  }
-  extractClassComponent(node, sourceFile, components) {
-    if (!import_ts_morph4.Node.isClassDeclaration(node))
-      return;
-    const name = node.getName();
-    if (!name || !this.looksLikeClassComponent(node))
-      return;
-    const description = this.extractJSDocDescription(node);
-    components.push({
-      name,
-      type: "class",
-      filePath: sourceFile.getFilePath(),
-      line: node.getStartLineNumber(),
-      props: this.extractPropsFromClass(node),
-      ...description ? { description } : {}
-    });
-  }
-  looksLikeComponent(name, node) {
-    if (!/^[A-Z]/.test(name))
-      return false;
-    const body = node.getBody();
-    if (!body)
-      return false;
-    let hasJSX = false;
-    if (import_ts_morph4.Node.isBlock(body)) {
-      body.forEachDescendant((child) => {
-        if (import_ts_morph4.Node.isJsxElement(child) || import_ts_morph4.Node.isJsxSelfClosingElement(child)) {
-          hasJSX = true;
-        }
-      });
-    } else if (import_ts_morph4.Node.isJsxElement(body) || import_ts_morph4.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 type2 = propsParam.getType();
-    const props = [];
-    for (const prop of type2.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);
-  }
-}
-var import_ts_morph4;
-var init_contexts = __esm(() => {
-  import_ts_morph4 = __toESM(require_ts_morph(), 1);
-});
-
-// tools/analysis/src/extract/flows.ts
-class FlowAnalyzer {
-  project;
-  handlers;
-  constructor(tsConfigPath, handlers) {
-    this.project = new import_ts_morph5.Project({
-      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,
-          ...flowMetadata.trigger ? { trigger: flowMetadata.trigger } : {},
-          ...flowMetadata.flowName ? { flowName: flowMetadata.flowName } : {},
-          ...flowMetadata.description ? { 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) => {
-        this.processMessageSender(node, messageType, context, filePath, senders);
-      });
-    }
-    return senders;
-  }
-  processMessageSender(node, messageType, context, filePath, senders) {
-    if (!import_ts_morph5.Node.isCallExpression(node)) {
-      return;
-    }
-    const expression = node.getExpression();
-    if (import_ts_morph5.Node.isPropertyAccessExpression(expression)) {
-      this.processPropertyAccessSender(node, expression, messageType, context, filePath, senders);
-    } else if (import_ts_morph5.Node.isIdentifier(expression)) {
-      this.processIdentifierSender(node, expression, messageType, context, filePath, senders);
-    }
-  }
-  processPropertyAccessSender(node, expression, messageType, context, filePath, senders) {
-    if (!import_ts_morph5.Node.isPropertyAccessExpression(expression)) {
-      return;
-    }
-    const methodName = expression.getName();
-    if (!this.isMessageSendMethod(methodName)) {
-      return;
-    }
-    const args = node.getArguments();
-    if (args.length === 0) {
-      return;
-    }
-    const msgType = this.extractMessageTypeFromArg(args[0]);
-    if (msgType === messageType) {
-      senders.push({
-        context,
-        file: filePath,
-        line: node.getStartLineNumber()
-      });
-    }
-  }
-  processIdentifierSender(node, expression, messageType, context, filePath, senders) {
-    if (!import_ts_morph5.Node.isIdentifier(expression)) {
-      return;
-    }
-    if (expression.getText() !== "postMessage") {
-      return;
-    }
-    const args = node.getArguments();
-    if (args.length === 0) {
-      return;
-    }
-    const msgType = this.extractMessageTypeFromArg(args[0]);
-    if (msgType === messageType) {
-      senders.push({
-        context,
-        file: filePath,
-        line: node.getStartLineNumber()
-      });
-    }
-  }
-  isMessageSendMethod(methodName) {
-    return methodName === "send" || methodName === "emit" || methodName === "postMessage" || methodName === "broadcast";
-  }
-  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) => {
-      this.processSendCall(node, targetLine, handler.location.file, sends);
-    });
-    return sends;
-  }
-  processSendCall(node, targetLine, filePath, sends) {
-    if (!import_ts_morph5.Node.isCallExpression(node)) {
-      return;
-    }
-    const line = node.getStartLineNumber();
-    if (!this.isNearLine(line, targetLine)) {
-      return;
-    }
-    const expression = node.getExpression();
-    if (!this.isSendOrEmitCall(expression)) {
-      return;
-    }
-    const args = node.getArguments();
-    if (args.length === 0) {
-      return;
-    }
-    const messageType = this.extractMessageTypeFromArg(args[0]);
-    if (messageType) {
-      sends.push({
-        messageType,
-        location: { file: filePath, line }
-      });
-    }
-  }
-  isNearLine(line, targetLine) {
-    return Math.abs(line - targetLine) < 20;
-  }
-  isSendOrEmitCall(expression) {
-    if (!import_ts_morph5.Node.isPropertyAccessExpression(expression)) {
-      return false;
-    }
-    const methodName = expression.getName();
-    return methodName === "send" || methodName === "emit";
-  }
-  extractMessageTypeFromArg(arg) {
-    if (import_ts_morph5.Node.isStringLiteral(arg)) {
-      return arg.getLiteralValue();
-    }
-    if (import_ts_morph5.Node.isObjectLiteralExpression(arg)) {
-      return this.extractMessageTypeFromObject(arg);
-    }
-    return;
-  }
-  extractMessageTypeFromObject(obj) {
-    if (!import_ts_morph5.Node.isObjectLiteralExpression(obj)) {
-      return;
-    }
-    const typeProperty = obj.getProperty("type");
-    if (!typeProperty || !import_ts_morph5.Node.isPropertyAssignment(typeProperty)) {
-      return;
-    }
-    const initializer = typeProperty.getInitializer();
-    if (!initializer || !import_ts_morph5.Node.isStringLiteral(initializer)) {
-      return;
-    }
-    return initializer.getLiteralValue();
-  }
-  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 path = filePath.toLowerCase();
-    const contextPatterns = [
-      { context: "background", patterns: ["/background/", "\\background\\"] },
-      { context: "content", patterns: ["/content/", "\\content\\"] },
-      { context: "popup", patterns: ["/popup/", "\\popup\\"] },
-      { context: "devtools", patterns: ["/devtools/", "\\devtools\\"] },
-      { context: "options", patterns: ["/options/", "\\options\\"] },
-      { context: "offscreen", patterns: ["/offscreen/", "\\offscreen\\"] },
-      { context: "server", patterns: ["/server/", "\\server\\", "/server."] },
-      { context: "client", patterns: ["/client/", "\\client\\", "/client."] },
-      { context: "worker", patterns: ["/worker/", "\\worker\\", "service-worker"] }
-    ];
-    for (const { context, patterns } of contextPatterns) {
-      if (patterns.some((pattern) => path.includes(pattern))) {
-        return context;
-      }
-    }
-    return "unknown";
-  }
-}
-var import_ts_morph5;
-var init_flows = __esm(() => {
-  import_ts_morph5 = __toESM(require_ts_morph(), 1);
-});
-
-// tools/analysis/src/extract/integrations.ts
-class IntegrationAnalyzer {
-  project;
-  constructor(tsConfigPath) {
-    this.project = new import_ts_morph6.Project({
-      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) => {
-        this.processFetchCall(node, sourceFile, calls);
-      });
-    }
-    return calls;
-  }
-  processFetchCall(node, sourceFile, calls) {
-    if (!import_ts_morph6.Node.isCallExpression(node)) {
-      return;
-    }
-    const expression = node.getExpression();
-    if (!this.isFetchCall(expression)) {
-      return;
-    }
-    const args = node.getArguments();
-    if (args.length === 0) {
-      return;
-    }
-    const url = this.extractURLFromArg(args[0]);
-    if (!url) {
-      return;
-    }
-    const method = this.extractMethodFromOptions(args);
-    const description = this.extractJSDocDescription(node);
-    calls.push({
-      url,
-      method,
-      file: sourceFile.getFilePath(),
-      line: node.getStartLineNumber(),
-      description
-    });
-  }
-  isFetchCall(expression) {
-    return import_ts_morph6.Node.isIdentifier(expression) && expression.getText() === "fetch";
-  }
-  extractURLFromArg(urlArg) {
-    if (import_ts_morph6.Node.isStringLiteral(urlArg)) {
-      return urlArg.getLiteralValue();
-    }
-    if (import_ts_morph6.Node.isTemplateExpression(urlArg)) {
-      return this.extractBaseURL(urlArg.getText());
-    }
-    return null;
-  }
-  extractMethodFromOptions(args) {
-    const defaultMethod = "GET";
-    if (args.length <= 1) {
-      return defaultMethod;
-    }
-    const optionsArg = args[1];
-    if (!import_ts_morph6.Node.isObjectLiteralExpression(optionsArg)) {
-      return defaultMethod;
-    }
-    const methodProp = optionsArg.getProperty("method");
-    if (!methodProp || !import_ts_morph6.Node.isPropertyAssignment(methodProp)) {
-      return defaultMethod;
-    }
-    const initializer = methodProp.getInitializer();
-    if (!initializer || !import_ts_morph6.Node.isStringLiteral(initializer)) {
-      return defaultMethod;
-    }
-    return initializer.getLiteralValue().toUpperCase();
-  }
-  findWebSockets() {
-    const websockets = [];
-    for (const sourceFile of this.project.getSourceFiles()) {
-      sourceFile.forEachDescendant((node) => {
-        if (import_ts_morph6.Node.isNewExpression(node)) {
-          const expression = node.getExpression();
-          if (import_ts_morph6.Node.isIdentifier(expression) && expression.getText() === "WebSocket") {
-            const args = node.getArguments();
-            if (args.length > 0 && import_ts_morph6.Node.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()) {
-      this.extractExternalImportsFromFile(sourceFile, scripts, seen);
-    }
-    return scripts;
-  }
-  extractExternalImportsFromFile(sourceFile, scripts, seen) {
-    for (const importDecl of sourceFile.getImportDeclarations()) {
-      const moduleSpecifier = importDecl.getModuleSpecifierValue();
-      if (this.isExternalImport(moduleSpecifier)) {
-        const packageName = this.extractPackageName(moduleSpecifier);
-        if (packageName && !seen.has(packageName)) {
-          seen.add(packageName);
-          scripts.push(this.createExternalScriptIntegration(packageName, sourceFile));
-        }
-      }
-    }
-  }
-  isExternalImport(moduleSpecifier) {
-    return !moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/");
-  }
-  extractPackageName(moduleSpecifier) {
-    if (moduleSpecifier.startsWith("@")) {
-      return moduleSpecifier.split("/").slice(0, 2).join("/");
-    }
-    return moduleSpecifier.split("/")[0];
-  }
-  createExternalScriptIntegration(packageName, sourceFile) {
-    return {
-      type: "external-script",
-      name: packageName,
-      technology: "npm package",
-      usedIn: [sourceFile.getFilePath()],
-      description: `External dependency: ${packageName}`
-    };
-  }
-  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) {
-    let cleanUrl = url.replace(/\$\{[^}]+\}/g, "");
-    cleanUrl = cleanUrl.replace(/`/g, "");
-    try {
-      const parsed = new URL(cleanUrl);
-      return `${parsed.protocol}//${parsed.host}`;
-    } catch {
-      const match = cleanUrl.match(/https?:\/\/([^/]+)/);
-      return match ? match[0] : cleanUrl;
-    }
-  }
-  inferAPIName(url) {
-    try {
-      const parsed = new URL(url);
-      const hostname2 = parsed.hostname;
-      const cleanHost = hostname2.replace(/^www\./, "");
-      const parts = cleanHost.split(".");
-      if (parts.length > 0 && parts[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);
-      if (!existing)
-        return;
-      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;
-  }
-}
-var import_ts_morph6;
-var init_integrations = __esm(() => {
-  import_ts_morph6 = __toESM(require_ts_morph(), 1);
-});
-
-// tools/analysis/src/extract/adr.ts
-var fs2 = (() => ({}));
-
-class ADRExtractor {
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-  }
-  extract() {
-    const adrDir = this.findADRDirectory();
-    if (!adrDir || !fs2.existsSync(adrDir)) {
-      return {
-        adrs: [],
-        directory: adrDir || join(this.projectRoot, "docs", "adr")
-      };
-    }
-    const files = fs2.readdirSync(adrDir).filter((file) => file.endsWith(".md")).map((file) => join(adrDir, file));
-    const adrs = [];
-    for (const file of files) {
-      try {
-        const adr2 = this.parseADR(file);
-        if (adr2) {
-          adrs.push(adr2);
-        }
-      } catch (error) {
-        if (process.env["POLLY_DEBUG"]) {
-          console.log(`[DEBUG] Failed to parse ADR file ${file}: ${error}`);
-        }
-      }
-    }
-    adrs.sort((a, b) => a.id.localeCompare(b.id));
-    return {
-      adrs,
-      directory: adrDir
-    };
-  }
-  findADRDirectory() {
-    const candidates = [
-      join(this.projectRoot, "docs", "adr"),
-      join(this.projectRoot, "docs", "architecture", "decisions"),
-      join(this.projectRoot, "adr"),
-      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 = basename(filePath, ".md");
-    const idMatch = fileName.match(/^(\d+)/);
-    const id = idMatch?.[1] ?? fileName;
-    const titleMatch = content.match(/^#\s+(.+)$/m);
-    const title = 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 && alternatives.length > 0 ? { alternatives } : {},
-      ...links.length > 0 ? { links } : {},
-      source: filePath
-    };
-  }
-  extractStatus(content) {
-    const statusMatch = content.match(/Status:\s*(\w+)/i);
-    if (!statusMatch)
-      return "accepted";
-    const status = statusMatch[1]?.toLowerCase();
-    if (status && ["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);
-    if (dateMatch?.[1]) {
-      return dateMatch[1];
-    }
-    const isoDate = new Date().toISOString().split("T")[0];
-    return isoDate || new Date().toLocaleDateString("en-CA");
-  }
-  extractSection(content, sectionName) {
-    const regex = new RegExp(`##\\s+${sectionName}\\s*\\n([\\s\\S]*?)(?=\\n##|$)`, "i");
-    const match = content.match(regex);
-    return 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+)/);
-        const id = idMatch?.[1];
-        if (id) {
-          links.push({
-            type: "supersedes",
-            adrId: id
-          });
-        }
-      }
-    }
-    const supersededByMatch = content.match(/Superseded by:\s*ADR-(\d+)/gi);
-    if (supersededByMatch) {
-      for (const match of supersededByMatch) {
-        const idMatch = match.match(/ADR-(\d+)/);
-        const id = idMatch?.[1];
-        if (id) {
-          links.push({
-            type: "superseded-by",
-            adrId: id
-          });
-        }
-      }
-    }
-    return links;
-  }
-}
-function extractADRs(projectRoot) {
-  const extractor = new ADRExtractor(projectRoot);
-  return extractor.extract();
-}
-var init_adr = __esm(() => {
-  init_path();
-});
-
 // tools/analysis/src/extract/project-detector.ts
 var exports_project_detector = {};
 __export(exports_project_detector, {
@@ -239052,18 +238622,448 @@ var init_architecture = __esm(() => {
   init_manifest();
 });
 
+// tools/analysis/src/extract/types.ts
+class TypeExtractor {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new import_ts_morph6.Project({
+      tsConfigFilePath: tsConfigPath
+    });
+  }
+  async analyzeCodebase(stateFilePath) {
+    const stateType = stateFilePath ? this.extractStateType(stateFilePath) : this.findStateType();
+    const messageTypes = this.findMessageTypes();
+    const fields = stateType ? this.analyzeFields(stateType) : [];
+    const handlerAnalysis = this.extractHandlerAnalysis();
+    const validMessageTypes = this.filterAndLogMessageTypes(messageTypes, handlerAnalysis.messageTypes);
+    const validHandlers = this.filterAndLogHandlers(handlerAnalysis.handlers);
+    return {
+      stateType,
+      messageTypes: validMessageTypes,
+      fields,
+      handlers: validHandlers
+    };
+  }
+  extractHandlerAnalysis() {
+    const configFilePath = this.project.getCompilerOptions()["configFilePath"];
+    const tsConfigPath = typeof configFilePath === "string" ? configFilePath : "tsconfig.json";
+    const handlerExtractor = new HandlerExtractor(tsConfigPath);
+    return handlerExtractor.extractHandlers();
+  }
+  filterAndLogMessageTypes(messageTypes, handlerMessageTypes) {
+    const allMessageTypes = Array.from(new Set([...messageTypes, ...handlerMessageTypes]));
+    const validMessageTypes = [];
+    const invalidMessageTypes = [];
+    for (const msgType of allMessageTypes) {
+      if (this.isValidTLAIdentifier(msgType)) {
+        validMessageTypes.push(msgType);
+      } else {
+        invalidMessageTypes.push(msgType);
+      }
+    }
+    this.logInvalidMessageTypes(invalidMessageTypes);
+    return validMessageTypes;
+  }
+  logInvalidMessageTypes(invalidMessageTypes) {
+    if (invalidMessageTypes.length === 0 || !process.env["POLLY_DEBUG"])
+      return;
+    console.log(`[WARN] Filtered out ${invalidMessageTypes.length} invalid message type(s):`);
+    for (const invalid of invalidMessageTypes) {
+      console.log(`[WARN]   - "${invalid}" (not a valid TLA+ identifier)`);
+    }
+  }
+  filterAndLogHandlers(handlers) {
+    const validHandlers = handlers.filter((h) => this.isValidTLAIdentifier(h.messageType));
+    this.logInvalidHandlers(handlers, validHandlers);
+    return validHandlers;
+  }
+  logInvalidHandlers(allHandlers, validHandlers) {
+    const filteredHandlerCount = allHandlers.length - validHandlers.length;
+    if (filteredHandlerCount === 0 || !process.env["POLLY_DEBUG"])
+      return;
+    console.log(`[WARN] Filtered out ${filteredHandlerCount} handler(s) with invalid message types:`);
+    for (const handler of allHandlers) {
+      if (!this.isValidTLAIdentifier(handler.messageType)) {
+        console.log(`[WARN]   - Handler for "${handler.messageType}" at ${handler.location.file}:${handler.location.line}`);
+      }
+    }
+  }
+  isValidTLAIdentifier(s) {
+    if (!s || s.length === 0) {
+      return false;
+    }
+    return /^[a-zA-Z][a-zA-Z0-9_]*$/.test(s);
+  }
+  extractStateType(filePath) {
+    const sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) {
+      return null;
+    }
+    const typeAlias = sourceFile.getTypeAlias("AppState") || sourceFile.getTypeAlias("State") || sourceFile.getTypeAliases()[0];
+    if (!typeAlias) {
+      return null;
+    }
+    const type2 = typeAlias.getType();
+    return this.convertType(type2, typeAlias.getName());
+  }
+  findStateType() {
+    const stateFiles = this.project.getSourceFiles("**/state*.ts");
+    for (const file of stateFiles) {
+      const typeAlias = file.getTypeAlias("AppState") || file.getTypeAlias("State");
+      if (typeAlias) {
+        const type2 = typeAlias.getType();
+        return this.convertType(type2, typeAlias.getName());
+      }
+    }
+    return null;
+  }
+  findMessageTypes() {
+    const messageTypes = [];
+    const warnings = [];
+    const messageFiles = this.project.getSourceFiles("**/message*.ts");
+    for (const file of messageFiles) {
+      for (const typeAlias of file.getTypeAliases()) {
+        const extractedTypes = this.extractMessageTypesFromType(typeAlias.getType(), typeAlias.getName(), file, warnings);
+        messageTypes.push(...extractedTypes);
+      }
+    }
+    if (warnings.length > 0 && process.env["POLLY_DEBUG"]) {
+      console.log("[WARN] Message type extraction warnings:");
+      for (const warning of warnings) {
+        console.log(`[WARN]   ${warning}`);
+      }
+    }
+    return [...new Set(messageTypes)];
+  }
+  extractMessageTypesFromType(type2, typeName, sourceFile, warnings) {
+    if (type2.isUnion()) {
+      return this.extractFromUnionType(type2, typeName, sourceFile, warnings);
+    }
+    if (type2.getAliasSymbol()) {
+      return this.extractFromTypeAlias(type2, typeName, sourceFile, warnings);
+    }
+    if (type2.isConditionalType?.()) {
+      return this.extractFromConditionalType(type2, warnings);
+    }
+    if (type2.getText().includes("[K in ")) {
+      return this.extractFromMappedType(type2, sourceFile, warnings);
+    }
+    if (type2.getText().includes("`")) {
+      this.warnTemplateLiteral(type2, warnings);
+      return [];
+    }
+    return [];
+  }
+  extractFromUnionType(type2, typeName, sourceFile, warnings) {
+    const messageTypes = [];
+    const unionTypes = type2.getUnionTypes();
+    for (const unionType of unionTypes) {
+      const extracted = this.extractFromUnionMember(unionType, typeName, sourceFile, warnings);
+      messageTypes.push(...extracted);
+    }
+    return messageTypes;
+  }
+  extractFromUnionMember(unionType, typeName, sourceFile, warnings) {
+    if (unionType.isObject()) {
+      return this.extractFromDiscriminatedUnion(unionType, sourceFile, warnings);
+    }
+    if (unionType.isStringLiteral()) {
+      return [unionType.getLiteralValue()];
+    }
+    if (unionType.getAliasSymbol()) {
+      const aliasedType = unionType.getAliasSymbol()?.getDeclaredType();
+      if (aliasedType) {
+        return this.extractMessageTypesFromType(aliasedType, typeName, sourceFile, warnings);
+      }
+    }
+    return [];
+  }
+  extractFromDiscriminatedUnion(unionType, sourceFile, warnings) {
+    const typeProperty = unionType.getProperty("type");
+    if (!typeProperty) {
+      return [];
+    }
+    const typeType = typeProperty.getTypeAtLocation(sourceFile);
+    if (typeType.isStringLiteral()) {
+      return [typeType.getLiteralValue()];
+    }
+    if (typeType.getText().includes("`")) {
+      warnings.push(`Template literal type in discriminant: ${typeType.getText()} - may be unbounded`);
+    }
+    return [];
+  }
+  extractFromTypeAlias(type2, typeName, sourceFile, warnings) {
+    const aliasedType = type2.getAliasSymbol()?.getDeclaredType();
+    if (!aliasedType || aliasedType === type2) {
+      return [];
+    }
+    return this.extractMessageTypesFromType(aliasedType, typeName, sourceFile, warnings);
+  }
+  extractFromConditionalType(type2, warnings) {
+    warnings.push(`Conditional type detected: ${type2.getText()} - extracting conservatively`);
+    const messageTypes = [];
+    const typeText = type2.getText();
+    const parts = typeText.split("?");
+    if (parts.length < 2) {
+      return messageTypes;
+    }
+    const branches = parts[1].split(":");
+    for (const branch of branches) {
+      const extracted = this.extractStringLiteralFromBranch(branch);
+      if (extracted) {
+        messageTypes.push(extracted);
+      }
+    }
+    return messageTypes;
+  }
+  extractStringLiteralFromBranch(branch) {
+    const trimmed = branch.trim();
+    const match = trimmed.match(/^["'](\w+)["']$/);
+    return match?.[1] ?? null;
+  }
+  extractFromMappedType(type2, sourceFile, warnings) {
+    warnings.push(`Mapped type detected: ${type2.getText()} - attempting to extract keys`);
+    const match = type2.getText().match(/\[K in ([^\]]+)\]/);
+    if (!match?.[1]) {
+      return [];
+    }
+    const keyTypeName = match[1].trim();
+    const keyTypeAlias = sourceFile.getTypeAlias?.(keyTypeName);
+    if (!keyTypeAlias) {
+      return [];
+    }
+    const keyType = keyTypeAlias.getType();
+    return this.extractMessageTypesFromType(keyType, keyTypeName, sourceFile, warnings);
+  }
+  warnTemplateLiteral(type2, warnings) {
+    warnings.push(`Template literal type: ${type2.getText()} - this creates an unbounded set and cannot be fully extracted`);
+  }
+  convertType(type2, name) {
+    const nullable = type2.isNullable();
+    if (type2.isBoolean() || type2.isBooleanLiteral()) {
+      return { name, kind: "boolean", nullable };
+    }
+    if (type2.isUnion()) {
+      return this.convertUnionType(type2, name, nullable);
+    }
+    if (type2.isString() || type2.isStringLiteral()) {
+      return { name, kind: "string", nullable };
+    }
+    if (type2.isNumber() || type2.isNumberLiteral()) {
+      return { name, kind: "number", nullable };
+    }
+    if (type2.isArray()) {
+      return this.convertArrayType(type2, name, nullable);
+    }
+    const collectionType = this.tryConvertCollectionType(type2, name, nullable);
+    if (collectionType) {
+      return collectionType;
+    }
+    if (type2.isObject()) {
+      return this.convertObjectType(type2, name, nullable);
+    }
+    if (type2.isNull()) {
+      return { name, kind: "null", nullable: true };
+    }
+    return { name, kind: "unknown", nullable };
+  }
+  convertUnionType(type2, name, nullable) {
+    const unionTypes = type2.getUnionTypes();
+    const allStringLiterals = unionTypes.every((t) => t.isStringLiteral());
+    if (allStringLiterals) {
+      const enumValues = unionTypes.map((t) => t.getLiteralValue());
+      return { name, kind: "enum", nullable, enumValues };
+    }
+    const nonNullTypes = unionTypes.filter((t) => !t.isNull() && !t.isUndefined());
+    if (nonNullTypes.length === 1) {
+      const firstType = nonNullTypes[0];
+      if (firstType) {
+        const baseType = this.convertType(firstType, name);
+        return { ...baseType, nullable: true };
+      }
+    }
+    return {
+      name,
+      kind: "union",
+      nullable,
+      unionTypes: unionTypes.map((t, i2) => this.convertType(t, `${name}_${i2}`))
+    };
+  }
+  convertArrayType(type2, name, nullable) {
+    const elementType = type2.getArrayElementType();
+    return {
+      name,
+      kind: "array",
+      nullable,
+      elementType: elementType ? this.convertType(elementType, `${name}_element`) : { name: "unknown", kind: "unknown", nullable: false }
+    };
+  }
+  tryConvertCollectionType(type2, name, nullable) {
+    const symbol = type2.getSymbol();
+    if (!symbol)
+      return null;
+    const symbolName = symbol.getName();
+    if (symbolName === "Map") {
+      const typeArgs = type2.getTypeArguments();
+      return {
+        name,
+        kind: "map",
+        nullable,
+        valueType: typeArgs?.[1] ? this.convertType(typeArgs[1], `${name}_value`) : undefined
+      };
+    }
+    if (symbolName === "Set") {
+      const typeArgs = type2.getTypeArguments();
+      return {
+        name,
+        kind: "set",
+        nullable,
+        elementType: typeArgs?.[0] ? this.convertType(typeArgs[0], `${name}_element`) : undefined
+      };
+    }
+    return null;
+  }
+  convertObjectType(type2, name, nullable) {
+    const properties = {};
+    const sourceFile = this.project.getSourceFiles()[0];
+    if (sourceFile) {
+      for (const prop of type2.getProperties()) {
+        const propName = prop.getName();
+        const propType = prop.getTypeAtLocation(sourceFile);
+        properties[propName] = this.convertType(propType, propName);
+      }
+    }
+    return { name, kind: "object", nullable, properties };
+  }
+  analyzeFields(stateType, prefix = "") {
+    const fields = [];
+    if (stateType.kind === "object" && stateType.properties) {
+      for (const [key, propType] of Object.entries(stateType.properties)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (propType.kind === "object") {
+          fields.push(...this.analyzeFields(propType, path));
+        } else {
+          const analysis = this.analyzeField(path, propType);
+          fields.push(analysis);
+        }
+      }
+    }
+    return fields;
+  }
+  analyzeField(path, type2) {
+    const analysis = {
+      path,
+      type: type2,
+      confidence: "low",
+      evidence: [],
+      suggestions: [],
+      bounds: {}
+    };
+    if (type2.kind === "boolean")
+      return this.analyzeBooleanField(analysis);
+    if (type2.kind === "enum")
+      return this.analyzeEnumField(analysis, type2);
+    if (type2.kind === "array")
+      return this.analyzeArrayField(analysis);
+    if (type2.kind === "number")
+      return this.analyzeNumberField(analysis);
+    if (type2.kind === "string")
+      return this.analyzeStringField(analysis);
+    if (type2.kind === "map" || type2.kind === "set")
+      return this.analyzeMapSetField(analysis);
+    return analysis;
+  }
+  analyzeBooleanField(analysis) {
+    analysis.confidence = "high";
+    analysis.evidence.push("Boolean type - auto-configured");
+    return analysis;
+  }
+  analyzeEnumField(analysis, type2) {
+    if (type2.enumValues) {
+      analysis.confidence = "high";
+      analysis.evidence.push(`Enum with ${type2.enumValues.length} values`);
+      if (analysis.bounds) {
+        analysis.bounds.values = type2.enumValues;
+      }
+    }
+    return analysis;
+  }
+  analyzeArrayField(analysis) {
+    analysis.confidence = "low";
+    analysis.suggestions.push("Choose maxLength: 5 (fast), 10 (balanced), or 20 (thorough)");
+    if (analysis.bounds) {
+      analysis.bounds.maxLength = undefined;
+    }
+    const foundBound = this.findArrayBound();
+    if (foundBound && analysis.bounds) {
+      analysis.confidence = "medium";
+      analysis.evidence.push(`Found array check: ${foundBound.evidence}`);
+      analysis.bounds.maxLength = foundBound.value;
+    }
+    return analysis;
+  }
+  analyzeNumberField(analysis) {
+    analysis.confidence = "low";
+    analysis.suggestions.push("Provide min and max values based on your application logic");
+    if (analysis.bounds) {
+      analysis.bounds.min = undefined;
+      analysis.bounds.max = undefined;
+    }
+    const foundBound = this.findNumberBound();
+    if (foundBound && analysis.bounds) {
+      analysis.confidence = "high";
+      analysis.evidence.push(`Found comparison: ${foundBound.evidence}`);
+      analysis.bounds = { ...analysis.bounds, ...foundBound.bounds };
+    }
+    return analysis;
+  }
+  analyzeStringField(analysis) {
+    analysis.confidence = "low";
+    analysis.suggestions.push('Provide 2-3 example values: ["value1", "value2", "value3"]', "Or use { abstract: true } for symbolic verification");
+    if (analysis.bounds) {
+      analysis.bounds.values = undefined;
+    }
+    return analysis;
+  }
+  analyzeMapSetField(analysis) {
+    analysis.confidence = "low";
+    analysis.suggestions.push("Provide maxSize (recommended: 3-5)");
+    if (analysis.bounds) {
+      analysis.bounds.maxSize = undefined;
+    }
+    return analysis;
+  }
+  findArrayBound() {
+    return null;
+  }
+  findNumberBound() {
+    return null;
+  }
+}
+async function analyzeCodebase(options) {
+  const extractor = new TypeExtractor(options.tsConfigPath);
+  return extractor.analyzeCodebase(options.stateFilePath);
+}
+var import_ts_morph6;
+var init_types = __esm(() => {
+  init_handlers();
+  import_ts_morph6 = __toESM(require_ts_morph(), 1);
+});
+
 // tools/analysis/src/extract/index.ts
 var init_extract = __esm(() => {
-  init_types2();
-  init_handlers();
-  init_manifest();
+  init_adr();
+  init_architecture();
   init_contexts();
   init_flows();
+  init_handlers();
   init_integrations();
-  init_adr();
-  init_architecture();
+  init_manifest();
   init_project_detector();
+  init_types();
 });
+// tools/analysis/src/types/index.ts
+var init_types2 = () => {};
 
 // tools/analysis/src/index.ts
 var exports_src = {};
@@ -239086,8 +239086,8 @@ __export(exports_src, {
   ADRExtractor: () => ADRExtractor
 });
 var init_src = __esm(() => {
-  init_types();
   init_extract();
+  init_types2();
 });
 
 // tools/visualize/src/types/structurizr.ts
@@ -240436,4 +240436,4 @@ export {
   generateTeachingMaterial
 };
 
-//# debugId=59D49291B64A354564756E2164756E21
+//# debugId=E1CBC64B9CEE404064756E2164756E21