@fairfox/polly 0.17.0 → 0.18.0

package/dist/tools/verify/src/config.d.ts

@@ -1,3 +1,7 @@
+interface SubsystemConfig {
+    state: string[];
+    handlers: string[];
+}
 interface LegacyVerificationConfig {
     state: Record<string, unknown>;
     messages: {
@@ -18,6 +22,7 @@ interface LegacyVerificationConfig {
         timeout?: number;
         workers?: number;
     };
+    subsystems?: Record<string, SubsystemConfig>;
     tier2?: {
         temporalConstraints?: Array<{
             before: string;

package/dist/tools/verify/src/config.js.map

@@ -3,9 +3,9 @@
   "sources": ["../tools/verify/src/primitives/index.ts", "../tools/verify/src/config.ts"],
   "sourcesContent": [
     "// Verification primitives for formal verification\n// These are runtime no-ops but extracted during verification\n\n/**\n * Assert a precondition that must be true when the handler executes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   requires(state.user.loggedIn === false, \"User must not be logged in\")\n *   state.user.loggedIn = true\n * })\n */\nexport function requires(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Assert a postcondition that must be true after the handler completes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   state.user.loggedIn = true\n *   ensures(state.user.loggedIn === true, \"User must be logged in\")\n * })\n */\nexport function ensures(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Define a global invariant that must always hold.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ invariant\n *\n * @example\n * invariant(\"UserIdConsistent\", () =>\n *   state.user.loggedIn === false || state.user.id !== null\n * )\n */\nexport function invariant(_name: string, condition: () => boolean): void {\n  // Runtime no-op - only used during verification\n  // Name and condition are checked during static analysis only\n  void condition;\n}\n\n/**\n * Assert that a value is within a valid range.\n *\n * @example\n * requires(inRange(todoCount, 0, 100), \"Todo count must be 0-100\")\n */\nexport function inRange(value: number, min: number, max: number): boolean {\n  return value >= min && value <= max;\n}\n\n/**\n * Assert that a value is one of the allowed values.\n *\n * @example\n * requires(oneOf(state.user.role, [\"admin\", \"user\"]), \"Role must be admin or user\")\n */\nexport function oneOf<T>(value: T, allowed: T[]): boolean {\n  return allowed.includes(value);\n}\n\n/**\n * Assert that an array has a specific length constraint.\n *\n * @example\n * requires(hasLength(state.todos, { max: 10 }), \"Too many todos\")\n */\nexport function hasLength(array: unknown[], constraint: { min?: number; max?: number }): boolean {\n  if (constraint.min !== undefined && array.length < constraint.min) return false;\n  if (constraint.max !== undefined && array.length > constraint.max) return false;\n  return true;\n}\n\n/**\n * Declare state-level constraints for verification and optional runtime checking.\n * Maps message types to preconditions on state fields.\n *\n * The parser automatically wires these constraints to handlers during verification.\n * Optionally, constraints can be enforced at runtime by passing `{ runtime: true }`.\n *\n * @example\n * // Verification only (TLA+ generation)\n * const state = { loggedIn: false };\n *\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: { requires: \"state.loggedIn === true\", message: \"Must be logged in\" },\n *   BOOKMARK_ADD: { requires: \"state.loggedIn === true\", message: \"Must be logged in\" },\n * });\n *\n * @example\n * // Runtime enforcement (function predicates)\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: {\n *     requires: (state) => state.loggedIn === true,\n *     message: \"Must be logged in to logout\"\n *   },\n * }, { runtime: true });\n */\nexport function $constraints(\n  stateField: string,\n  constraints: Record<\n    string,\n    {\n      requires?: string | ((state: unknown) => boolean);\n      ensures?: string | ((state: unknown) => boolean);\n      message?: string;\n    }\n  >,\n  options?: { runtime?: boolean }\n): void {\n  // Register constraints for runtime checking if enabled\n  if (options?.runtime) {\n    // Import dynamically to avoid circular dependencies\n    // This is safe because it only happens at runtime, not during static analysis\n    // @ts-expect-error - Dynamic import path resolves correctly at runtime\n    import(\"../../../src/shared/lib/constraints.js\")\n      .then(({ registerConstraints }) => {\n        registerConstraints(stateField, constraints);\n      })\n      .catch(() => {\n        // Silently ignore - constraints module may not be available during static analysis\n      });\n  }\n\n  // For verification: Still a no-op at runtime\n  // Parser extracts these and wires them to TLA+ handlers\n}\n\n/**\n * Declare a global state constraint that prunes structurally impossible states.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLC CONSTRAINT clause, discarding states\n * that violate the predicate from the exploration queue entirely.\n *\n * Unlike `invariant()` (which checks but still explores), `stateConstraint()`\n * prevents the model checker from ever reaching the pruned states.\n *\n * @example\n * stateConstraint(\"LeaderRequiresConnection\", () =>\n *   !connectionState.value.isLeader || connectionState.value.status === \"connected\"\n * )\n */\nexport function stateConstraint(\n  name: string,\n  predicate: () => boolean,\n  options?: { message?: string }\n): void {\n  void name;\n  void predicate;\n  void options;\n}\n\n// Re-export for convenience\nexport const verify = {\n  requires,\n  ensures,\n  invariant,\n  inRange,\n  oneOf,\n  hasLength,\n  $constraints,\n  stateConstraint,\n};\n",
-    "// ═══════════════════════════════════════════════════════════════\n// Configuration Helper for @fairfox/polly/verify\n// ═══════════════════════════════════════════════════════════════\n//\n// Lightweight entry point for user configuration files.\n// Does NOT include heavy dependencies (ts-morph, analysis, etc.)\n// which are only needed by the CLI tool.\n\n// ─────────────────────────────────────────────────────────────────\n// Configuration Types (inlined to avoid heavy dependencies)\n// ─────────────────────────────────────────────────────────────────\n\n// Legacy verification configuration\ninterface LegacyVerificationConfig {\n  state: Record<string, unknown>;\n  messages: {\n    // Basic bounds\n    maxInFlight?: number;\n    maxTabs?: number;\n    maxClients?: number;\n    maxRenderers?: number;\n    maxWorkers?: number;\n    maxContexts?: number;\n\n    // Tier 1 Optimizations (no precision loss)\n    include?: string[]; // Only verify these message types\n    exclude?: string[]; // Exclude these message types (mutually exclusive with include)\n    symmetry?: string[][]; // Groups of symmetric message types [[type1, type2], [type3, type4]]\n    perMessageBounds?: Record<string, number>; // Different maxInFlight per message type\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n  onRelease?: \"warn\" | \"error\" | \"off\";\n\n  // Verification engine options\n  verification?: {\n    timeout?: number; // Timeout in seconds (0 = no timeout)\n    workers?: number; // Number of TLC workers\n  };\n\n  // Tier 2 Optimizations (controlled approximations)\n  tier2?: {\n    // Temporal constraints: ordering requirements between messages\n    temporalConstraints?: Array<{\n      before: string; // Message type that must occur first\n      after: string; // Message type that must occur after\n      description?: string; // Human-readable description\n    }>;\n\n    // Bounded exploration: limit depth for specific scenarios\n    boundedExploration?: {\n      maxDepth?: number; // Maximum state depth to explore\n      criticalPaths?: string[][]; // Sequences of message types that must be fully explored\n    };\n  };\n}\n\n// Adapter-based configuration (for future use)\ninterface AdapterVerificationConfig {\n  adapter: unknown; // Adapter interface not exported to avoid heavy deps\n  state: Record<string, unknown>;\n  bounds?: {\n    maxInFlight?: number;\n    [key: string]: unknown;\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n}\n\n// Union type for both config formats\ntype UnifiedVerificationConfig = LegacyVerificationConfig | AdapterVerificationConfig;\n\n/**\n * Define verification configuration with type checking\n *\n * Used in generated verification.config.ts files.\n *\n * @example\n * ```typescript\n * import { defineVerification } from '@fairfox/polly/verify'\n *\n * export default defineVerification({\n *   state: {\n *     \"user.role\": { type: \"enum\", values: [\"admin\", \"user\", \"guest\"] },\n *   },\n *   messages: {\n *     maxInFlight: 6,\n *     maxTabs: 2,\n *   },\n * })\n * ```\n */\nexport function defineVerification<T extends UnifiedVerificationConfig>(config: T): T {\n  // Validate configuration structure\n  if (\"adapter\" in config) {\n    // New adapter-based format\n    if (!config.adapter) {\n      throw new Error(\"Configuration must include an adapter\");\n    }\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n  } else if (\"messages\" in config) {\n    // Legacy format\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n    if (!config.messages) {\n      throw new Error(\"Legacy configuration must include messages bounds\");\n    }\n  } else {\n    throw new Error(\n      \"Invalid configuration format. Must include either 'adapter' (new format) or 'messages' (legacy format)\"\n    );\n  }\n\n  return config;\n}\n\n// Re-export verification primitives for user code\nexport {\n  $constraints,\n  ensures,\n  hasLength,\n  inRange,\n  oneOf,\n  requires,\n  stateConstraint,\n} from \"./primitives/index.js\";\n"
+    "// ═══════════════════════════════════════════════════════════════\n// Configuration Helper for @fairfox/polly/verify\n// ═══════════════════════════════════════════════════════════════\n//\n// Lightweight entry point for user configuration files.\n// Does NOT include heavy dependencies (ts-morph, analysis, etc.)\n// which are only needed by the CLI tool.\n\n// ─────────────────────────────────────────────────────────────────\n// Configuration Types (inlined to avoid heavy dependencies)\n// ─────────────────────────────────────────────────────────────────\n\n// Subsystem configuration for compositional verification\ninterface SubsystemConfig {\n  state: string[]; // Field names from parent state config\n  handlers: string[]; // Message type names\n}\n\n// Legacy verification configuration\ninterface LegacyVerificationConfig {\n  state: Record<string, unknown>;\n  messages: {\n    // Basic bounds\n    maxInFlight?: number;\n    maxTabs?: number;\n    maxClients?: number;\n    maxRenderers?: number;\n    maxWorkers?: number;\n    maxContexts?: number;\n\n    // Tier 1 Optimizations (no precision loss)\n    include?: string[]; // Only verify these message types\n    exclude?: string[]; // Exclude these message types (mutually exclusive with include)\n    symmetry?: string[][]; // Groups of symmetric message types [[type1, type2], [type3, type4]]\n    perMessageBounds?: Record<string, number>; // Different maxInFlight per message type\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n  onRelease?: \"warn\" | \"error\" | \"off\";\n\n  // Verification engine options\n  verification?: {\n    timeout?: number; // Timeout in seconds (0 = no timeout)\n    workers?: number; // Number of TLC workers\n  };\n\n  // Subsystem-scoped verification (compositional)\n  subsystems?: Record<string, SubsystemConfig>;\n\n  // Tier 2 Optimizations (controlled approximations)\n  tier2?: {\n    // Temporal constraints: ordering requirements between messages\n    temporalConstraints?: Array<{\n      before: string; // Message type that must occur first\n      after: string; // Message type that must occur after\n      description?: string; // Human-readable description\n    }>;\n\n    // Bounded exploration: limit depth for specific scenarios\n    boundedExploration?: {\n      maxDepth?: number; // Maximum state depth to explore\n      criticalPaths?: string[][]; // Sequences of message types that must be fully explored\n    };\n  };\n}\n\n// Adapter-based configuration (for future use)\ninterface AdapterVerificationConfig {\n  adapter: unknown; // Adapter interface not exported to avoid heavy deps\n  state: Record<string, unknown>;\n  bounds?: {\n    maxInFlight?: number;\n    [key: string]: unknown;\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n}\n\n// Union type for both config formats\ntype UnifiedVerificationConfig = LegacyVerificationConfig | AdapterVerificationConfig;\n\n/**\n * Define verification configuration with type checking\n *\n * Used in generated verification.config.ts files.\n *\n * @example\n * ```typescript\n * import { defineVerification } from '@fairfox/polly/verify'\n *\n * export default defineVerification({\n *   state: {\n *     \"user.role\": { type: \"enum\", values: [\"admin\", \"user\", \"guest\"] },\n *   },\n *   messages: {\n *     maxInFlight: 6,\n *     maxTabs: 2,\n *   },\n * })\n * ```\n */\nexport function defineVerification<T extends UnifiedVerificationConfig>(config: T): T {\n  // Validate configuration structure\n  if (\"adapter\" in config) {\n    // New adapter-based format\n    if (!config.adapter) {\n      throw new Error(\"Configuration must include an adapter\");\n    }\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n  } else if (\"messages\" in config) {\n    // Legacy format\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n    if (!config.messages) {\n      throw new Error(\"Legacy configuration must include messages bounds\");\n    }\n  } else {\n    throw new Error(\n      \"Invalid configuration format. Must include either 'adapter' (new format) or 'messages' (legacy format)\"\n    );\n  }\n\n  return config;\n}\n\n// Re-export verification primitives for user code\nexport {\n  $constraints,\n  ensures,\n  hasLength,\n  inRange,\n  oneOf,\n  requires,\n  stateConstraint,\n} from \"./primitives/index.js\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,QAAQ,CAAC,WAAoB,SAAwB;AAmB9D,SAAS,OAAO,CAAC,WAAoB,SAAwB;AA8B7D,SAAS,OAAO,CAAC,OAAe,KAAa,KAAsB;AAAA,EACxE,OAAO,SAAS,OAAO,SAAS;AAAA;AAS3B,SAAS,KAAQ,CAAC,OAAU,SAAuB;AAAA,EACxD,OAAO,QAAQ,SAAS,KAAK;AAAA;AASxB,SAAS,SAAS,CAAC,OAAkB,YAAqD;AAAA,EAC/F,IAAI,WAAW,QAAQ,aAAa,MAAM,SAAS,WAAW;AAAA,IAAK,OAAO;AAAA,EAC1E,IAAI,WAAW,QAAQ,aAAa,MAAM,SAAS,WAAW;AAAA,IAAK,OAAO;AAAA,EAC1E,OAAO;AAAA;AA4BF,SAAS,YAAY,CAC1B,YACA,aAQA,SACM;AAAA,EAEN,IAAI,SAAS,SAAS;AAAA,IAIb,iDACJ,KAAK,GAAG,0BAA0B;AAAA,MACjC,oBAAoB,YAAY,WAAW;AAAA,KAC5C,EACA,MAAM,MAAM,EAEZ;AAAA,EACL;AAAA;AAqBK,SAAS,eAAe,CAC7B,MACA,WACA,SACM;;;AC1ED,SAAS,kBAAuD,CAAC,QAAc;AAAA,EAEpF,IAAI,aAAa,QAAQ;AAAA,IAEvB,IAAI,CAAC,OAAO,SAAS;AAAA,MACnB,MAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF,EAAO,SAAI,cAAc,QAAQ;AAAA,IAE/B,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,IAAI,CAAC,OAAO,UAAU;AAAA,MACpB,MAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF,EAAO;AAAA,IACL,MAAM,IAAI,MACR,wGACF;AAAA;AAAA,EAGF,OAAO;AAAA;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,QAAQ,CAAC,WAAoB,SAAwB;AAmB9D,SAAS,OAAO,CAAC,WAAoB,SAAwB;AA8B7D,SAAS,OAAO,CAAC,OAAe,KAAa,KAAsB;AAAA,EACxE,OAAO,SAAS,OAAO,SAAS;AAAA;AAS3B,SAAS,KAAQ,CAAC,OAAU,SAAuB;AAAA,EACxD,OAAO,QAAQ,SAAS,KAAK;AAAA;AASxB,SAAS,SAAS,CAAC,OAAkB,YAAqD;AAAA,EAC/F,IAAI,WAAW,QAAQ,aAAa,MAAM,SAAS,WAAW;AAAA,IAAK,OAAO;AAAA,EAC1E,IAAI,WAAW,QAAQ,aAAa,MAAM,SAAS,WAAW;AAAA,IAAK,OAAO;AAAA,EAC1E,OAAO;AAAA;AA4BF,SAAS,YAAY,CAC1B,YACA,aAQA,SACM;AAAA,EAEN,IAAI,SAAS,SAAS;AAAA,IAIb,iDACJ,KAAK,GAAG,0BAA0B;AAAA,MACjC,oBAAoB,YAAY,WAAW;AAAA,KAC5C,EACA,MAAM,MAAM,EAEZ;AAAA,EACL;AAAA;AAqBK,SAAS,eAAe,CAC7B,MACA,WACA,SACM;;;ACjED,SAAS,kBAAuD,CAAC,QAAc;AAAA,EAEpF,IAAI,aAAa,QAAQ;AAAA,IAEvB,IAAI,CAAC,OAAO,SAAS;AAAA,MACnB,MAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF,EAAO,SAAI,cAAc,QAAQ;AAAA,IAE/B,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,IAAI,CAAC,OAAO,UAAU;AAAA,MACpB,MAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF,EAAO;AAAA,IACL,MAAM,IAAI,MACR,wGACF;AAAA;AAAA,EAGF,OAAO;AAAA;",
   "debugId": "465F57F5AB1A6BBD64756E2164756E21",
   "names": []
 }

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

@@ -39,6 +39,12 @@ class ProjectDetector {
     const packageJsonPath = path3.join(this.projectRoot, "package.json");
     if (fs3.existsSync(packageJsonPath)) {
       const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.workspaces) {
+        const monorepoConfig = this.detectMonorepo(packageJson);
+        if (monorepoConfig) {
+          return monorepoConfig;
+        }
+      }
       if (packageJson.dependencies?.electron || packageJson.devDependencies?.electron) {
         return this.detectElectron(packageJson);
       }
@@ -268,10 +274,11 @@ class ProjectDetector {
       }
     };
   }
-  scoreServerCandidates(candidates) {
+  scoreServerCandidates(candidates, baseDir) {
+    const root = baseDir || this.projectRoot;
     const scored = [];
     for (const candidate of candidates) {
-      const fullPath = path3.join(this.projectRoot, candidate);
+      const fullPath = path3.join(root, candidate);
       if (!fs3.existsSync(fullPath))
         continue;
       try {
@@ -426,6 +433,135 @@ class ProjectDetector {
     }
     return score;
   }
+  detectMonorepo(packageJson) {
+    const workspacesRaw = packageJson.workspaces;
+    const patterns = Array.isArray(workspacesRaw) ? workspacesRaw : Array.isArray(workspacesRaw?.packages) ? workspacesRaw.packages : [];
+    if (patterns.length === 0)
+      return null;
+    const workspaceDirs = this.resolveWorkspaceGlobs(patterns);
+    if (workspaceDirs.length === 0)
+      return null;
+    const entryPoints = {};
+    const contextMapping = {};
+    const workspacePackages = [];
+    for (const wsDir of workspaceDirs) {
+      const wsPkgPath = path3.join(wsDir, "package.json");
+      if (!fs3.existsSync(wsPkgPath))
+        continue;
+      let wsPkg;
+      try {
+        wsPkg = JSON.parse(fs3.readFileSync(wsPkgPath, "utf-8"));
+      } catch {
+        continue;
+      }
+      const pkgName = wsPkg.name || path3.basename(wsDir);
+      const context = this.inferContextFromPackageName(pkgName);
+      const serverCandidates = [
+        "src/server.ts",
+        "src/server.js",
+        "src/index.ts",
+        "src/index.js",
+        "src/main.ts",
+        "src/main.js",
+        "src/app.ts",
+        "src/app.js",
+        "server.ts",
+        "server.js",
+        "index.ts",
+        "index.js"
+      ];
+      const scoredServers = this.scoreServerCandidates(serverCandidates, wsDir);
+      if (scoredServers.length > 0) {
+        const best = scoredServers[0];
+        if (best) {
+          entryPoints[context] = best.path;
+          if (best.hasWebSocket) {
+            contextMapping[context] = "WebSocket Server";
+          } else if (best.hasHTTP) {
+            contextMapping[context] = "HTTP Server";
+          } else {
+            contextMapping[context] = this.capitalize(context);
+          }
+        }
+      } else {
+        const commonEntries = [
+          "src/index.ts",
+          "src/index.tsx",
+          "src/main.ts",
+          "src/main.tsx",
+          "src/app.ts",
+          "src/app.tsx",
+          "index.ts",
+          "index.tsx"
+        ];
+        for (const candidate of commonEntries) {
+          const fullPath = path3.join(wsDir, candidate);
+          if (fs3.existsSync(fullPath)) {
+            entryPoints[context] = fullPath;
+            contextMapping[context] = this.capitalize(context);
+            break;
+          }
+        }
+      }
+      workspacePackages.push({ name: pkgName, path: wsDir, context });
+    }
+    if (Object.keys(entryPoints).length === 0)
+      return null;
+    return {
+      type: "monorepo",
+      entryPoints,
+      contextMapping,
+      workspacePackages,
+      metadata: {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: packageJson.description
+      }
+    };
+  }
+  resolveWorkspaceGlobs(patterns) {
+    const dirs = [];
+    for (const pattern of patterns) {
+      if (pattern.includes("*")) {
+        const base = pattern.replace(/\/?\*.*$/, "");
+        const baseDir = path3.join(this.projectRoot, base);
+        if (fs3.existsSync(baseDir) && fs3.statSync(baseDir).isDirectory()) {
+          try {
+            const entries = fs3.readdirSync(baseDir, { withFileTypes: true });
+            for (const entry of entries) {
+              if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                dirs.push(path3.join(baseDir, entry.name));
+              }
+            }
+          } catch {}
+        }
+      } else {
+        const fullPath = path3.join(this.projectRoot, pattern);
+        if (fs3.existsSync(fullPath) && fs3.statSync(fullPath).isDirectory()) {
+          dirs.push(fullPath);
+        }
+      }
+    }
+    return dirs;
+  }
+  inferContextFromPackageName(name) {
+    const parts = name.split("/");
+    const baseName = name.includes("/") ? parts[parts.length - 1] || name : name;
+    const lower = baseName.toLowerCase();
+    const serverAliases = ["api", "server", "backend"];
+    if (serverAliases.includes(lower))
+      return "server";
+    const clientAliases = ["web", "app", "frontend", "client", "ui"];
+    if (clientAliases.includes(lower))
+      return "client";
+    const sharedAliases = ["shared", "common", "lib", "core", "utils"];
+    if (sharedAliases.includes(lower))
+      return "shared";
+    return lower;
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
   detectGenericProject() {
     const entryPoints = {};
     const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
@@ -915,11 +1051,13 @@ import { Node as Node2, Project as Project2 } from "ts-morph";
 class FlowAnalyzer {
   project;
   handlers;
-  constructor(tsConfigPath, handlers) {
+  contextOverrides;
+  constructor(tsConfigPath, handlers, contextOverrides) {
     this.project = new Project2({
       tsConfigFilePath: tsConfigPath
     });
     this.handlers = handlers;
+    this.contextOverrides = contextOverrides || new Map;
   }
   analyzeFlows() {
     const flows = [];
@@ -1155,6 +1293,10 @@ class FlowAnalyzer {
     return { trigger, flowName, description };
   }
   inferContext(filePath) {
+    for (const [pathPrefix, context] of this.contextOverrides.entries()) {
+      if (filePath.startsWith(pathPrefix))
+        return context;
+    }
     const path2 = filePath.toLowerCase();
     const contextPatterns = [
       { context: "background", patterns: ["/background/", "\\background\\"] },
@@ -1585,7 +1727,8 @@ class HandlerExtractor {
   packageRoot;
   warnings;
   currentFunctionParams = [];
-  constructor(tsConfigPath) {
+  contextOverrides;
+  constructor(tsConfigPath, contextOverrides) {
     this.project = new Project3({
       tsConfigFilePath: tsConfigPath
     });
@@ -1593,6 +1736,7 @@ class HandlerExtractor {
     this.relationshipExtractor = new RelationshipExtractor;
     this.analyzedFiles = new Set;
     this.warnings = [];
+    this.contextOverrides = contextOverrides || new Map;
     this.packageRoot = this.findPackageRoot(tsConfigPath);
   }
   warnUnsupportedPattern(pattern, location, suggestion) {
@@ -1810,8 +1954,20 @@ class HandlerExtractor {
           handlers.push(handler);
         }
       }
+      if (methodName === "ws") {
+        this.extractElysiaWsHandlers(node, context, filePath, handlers);
+      }
+      if (this.isRestMethod(methodName) && this.isWebFrameworkFile(node.getSourceFile())) {
+        const restHandler = this.extractRestHandler(node, methodName, context, filePath);
+        if (restHandler) {
+          handlers.push(restHandler);
+        }
+      }
     }
   }
+  isRestMethod(name) {
+    return ["get", "post", "put", "delete", "patch"].includes(name);
+  }
   isElseIfStatement(node) {
     const parent = node.getParent();
     return parent !== undefined && Node4.isIfStatement(parent);
@@ -1877,6 +2033,135 @@ class HandlerExtractor {
       parameters
     };
   }
+  extractElysiaWsHandlers(node, context, filePath, handlers) {
+    const args = node.getArguments();
+    if (args.length < 2)
+      return;
+    const routeArg = args[0];
+    if (!routeArg || !Node4.isStringLiteral(routeArg))
+      return;
+    const routePath = routeArg.getLiteralValue();
+    const configArg = args[1];
+    if (!configArg || !Node4.isObjectLiteralExpression(configArg))
+      return;
+    const callbacks = ["message", "open", "close"];
+    for (const cbName of callbacks) {
+      const prop = configArg.getProperty(cbName);
+      if (!prop)
+        continue;
+      let funcBody = null;
+      if (Node4.isMethodDeclaration(prop)) {
+        funcBody = prop;
+      } else if (Node4.isPropertyAssignment(prop)) {
+        const init = prop.getInitializer();
+        if (init && (Node4.isArrowFunction(init) || Node4.isFunctionExpression(init))) {
+          funcBody = init;
+        }
+      }
+      if (!funcBody)
+        continue;
+      if (cbName === "message") {
+        const body = funcBody.getBody();
+        if (!body)
+          continue;
+        const subHandlers = this.extractSubHandlersFromBody(body, context, filePath);
+        if (subHandlers.length > 0) {
+          handlers.push(...subHandlers);
+        } else {
+          handlers.push(this.buildWsHandler(`ws_message`, routePath, context, filePath, funcBody, node.getStartLineNumber()));
+        }
+      } else {
+        handlers.push(this.buildWsHandler(`ws_${cbName}`, routePath, context, filePath, funcBody, node.getStartLineNumber()));
+      }
+    }
+  }
+  extractSubHandlersFromBody(body, context, filePath) {
+    const subHandlers = [];
+    body.forEachDescendant((child) => {
+      if (Node4.isIfStatement(child) && !this.isElseIfStatement(child)) {
+        const typeGuardHandlers = this.extractTypeGuardHandlers(child, context, filePath);
+        subHandlers.push(...typeGuardHandlers);
+      }
+      if (Node4.isSwitchStatement(child)) {
+        const switchHandlers = this.extractSwitchCaseHandlers(child, context, filePath);
+        subHandlers.push(...switchHandlers);
+      }
+    });
+    return subHandlers;
+  }
+  buildWsHandler(messageType, _routePath, context, filePath, funcBody, line) {
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    this.currentFunctionParams = this.extractParameterNames(funcBody);
+    this.extractAssignments(funcBody, assignments);
+    this.extractVerificationConditions(funcBody, preconditions, postconditions);
+    this.currentFunctionParams = [];
+    return {
+      messageType,
+      node: context,
+      assignments,
+      preconditions,
+      postconditions,
+      location: { file: filePath, line },
+      origin: "event"
+    };
+  }
+  extractRestHandler(node, methodName, context, filePath) {
+    const args = node.getArguments();
+    if (args.length < 2)
+      return null;
+    const routeArg = args[0];
+    if (!routeArg || !Node4.isStringLiteral(routeArg))
+      return null;
+    const routePath = routeArg.getLiteralValue();
+    const httpMethod = methodName.toUpperCase();
+    const messageType = `${httpMethod} ${routePath}`;
+    const handlerArg = args[1];
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    let actualHandler = null;
+    if (Node4.isArrowFunction(handlerArg) || Node4.isFunctionExpression(handlerArg)) {
+      actualHandler = handlerArg;
+    } else if (Node4.isIdentifier(handlerArg)) {
+      actualHandler = this.resolveFunctionReference(handlerArg);
+    }
+    let parameters;
+    if (actualHandler) {
+      this.currentFunctionParams = this.extractParameterNames(actualHandler);
+      parameters = this.currentFunctionParams.length > 0 ? [...this.currentFunctionParams] : undefined;
+      this.extractAssignments(actualHandler, assignments);
+      this.extractVerificationConditions(actualHandler, preconditions, postconditions);
+      this.currentFunctionParams = [];
+    }
+    return {
+      messageType,
+      node: context,
+      assignments,
+      preconditions,
+      postconditions,
+      location: {
+        file: filePath,
+        line: node.getStartLineNumber()
+      },
+      origin: "event",
+      parameters,
+      handlerKind: "rest",
+      httpMethod,
+      routePath
+    };
+  }
+  isWebFrameworkFile(sourceFile) {
+    const frameworks = ["elysia", "express", "hono", "fastify", "koa", "@elysiajs/eden"];
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      const specifier = importDecl.getModuleSpecifierValue();
+      if (frameworks.some((fw) => specifier === fw || specifier.startsWith(`${fw}/`))) {
+        return true;
+      }
+    }
+    return false;
+  }
   extractAssignments(funcNode, assignments) {
     funcNode.forEachDescendant((node) => {
       if (Node4.isBinaryExpression(node)) {
@@ -2711,32 +2996,64 @@ class HandlerExtractor {
     try {
       const ifStmt = ifNode;
       const condition = ifStmt.getExpression();
-      if (!Node4.isCallExpression(condition)) {
-        return null;
+      if (Node4.isCallExpression(condition)) {
+        const funcExpr = condition.getExpression();
+        const funcName = Node4.isIdentifier(funcExpr) ? funcExpr.getText() : undefined;
+        this.debugLogProcessingFunction(funcName);
+        const messageType = this.resolveMessageType(funcExpr, funcName, typeGuards);
+        if (!messageType) {
+          this.debugLogUnresolvedMessageType(funcName);
+          return null;
+        }
+        const line = ifStmt.getStartLineNumber();
+        const relationships = this.extractRelationshipsFromIfBlock(ifStmt, messageType);
+        return {
+          messageType,
+          node: context,
+          assignments: [],
+          preconditions: [],
+          postconditions: [],
+          location: { file: filePath, line },
+          relationships
+        };
       }
-      const funcExpr = condition.getExpression();
-      const funcName = Node4.isIdentifier(funcExpr) ? funcExpr.getText() : undefined;
-      this.debugLogProcessingFunction(funcName);
-      const messageType = this.resolveMessageType(funcExpr, funcName, typeGuards);
-      if (!messageType) {
-        this.debugLogUnresolvedMessageType(funcName);
-        return null;
+      if (Node4.isBinaryExpression(condition)) {
+        const messageType = this.extractMessageTypeFromEqualityCheck(condition);
+        if (messageType) {
+          const line = ifStmt.getStartLineNumber();
+          const relationships = this.extractRelationshipsFromIfBlock(ifStmt, messageType);
+          return {
+            messageType,
+            node: context,
+            assignments: [],
+            preconditions: [],
+            postconditions: [],
+            location: { file: filePath, line },
+            relationships
+          };
+        }
       }
-      const line = ifStmt.getStartLineNumber();
-      const relationships = this.extractRelationshipsFromIfBlock(ifStmt, messageType);
-      return {
-        messageType,
-        node: context,
-        assignments: [],
-        preconditions: [],
-        postconditions: [],
-        location: { file: filePath, line },
-        relationships
-      };
+      return null;
     } catch (_error) {
       return null;
     }
   }
+  extractMessageTypeFromEqualityCheck(expr) {
+    const operator = expr.getOperatorToken().getText();
+    if (operator !== "===" && operator !== "==")
+      return null;
+    const left = expr.getLeft();
+    const right = expr.getRight();
+    const stringLiteral = Node4.isStringLiteral(right) ? right : Node4.isStringLiteral(left) ? left : null;
+    const propAccess = Node4.isPropertyAccessExpression(left) ? left : Node4.isPropertyAccessExpression(right) ? right : null;
+    if (!stringLiteral || !propAccess)
+      return null;
+    const propName = propAccess.getName();
+    if (propName !== "type" && propName !== "kind" && propName !== "action") {
+      return null;
+    }
+    return stringLiteral.getLiteralValue();
+  }
   debugLogProcessingFunction(funcName) {
     if (process.env["POLLY_DEBUG"] && funcName) {
       console.log(`[DEBUG] Processing if condition with function: ${funcName}`);
@@ -2946,6 +3263,10 @@ class HandlerExtractor {
     return messageType;
   }
   inferContext(filePath) {
+    for (const [pathPrefix, context] of this.contextOverrides.entries()) {
+      if (filePath.startsWith(pathPrefix))
+        return context;
+    }
     const path2 = filePath.toLowerCase();
     return this.inferElectronContext(path2) || this.inferWorkerContext(path2) || this.inferServerAppContext(path2) || this.inferChromeExtensionContext(path2) || "unknown";
   }
@@ -3894,10 +4215,16 @@ class ArchitectureAnalyzer {
   }
   async analyze() {
     const { manifest, projectConfig, entryPoints, systemInfo } = await this.initializeSystemInfo();
-    const handlerExtractor = new HandlerExtractor(this.options.tsConfigPath);
+    const contextOverrides = new Map;
+    if (projectConfig?.workspacePackages) {
+      for (const pkg of projectConfig.workspacePackages) {
+        contextOverrides.set(pkg.path, pkg.context);
+      }
+    }
+    const handlerExtractor = new HandlerExtractor(this.options.tsConfigPath, contextOverrides.size > 0 ? contextOverrides : undefined);
     const { handlers } = handlerExtractor.extractHandlers();
     const contexts = this.analyzeContexts(entryPoints, handlers);
-    const flowAnalyzer = new FlowAnalyzer(this.options.tsConfigPath, handlers);
+    const flowAnalyzer = new FlowAnalyzer(this.options.tsConfigPath, handlers, contextOverrides.size > 0 ? contextOverrides : undefined);
     const messageFlows = flowAnalyzer.analyzeFlows();
     const integrationAnalyzer = new IntegrationAnalyzer(this.options.tsConfigPath);
     const integrations = integrationAnalyzer.analyzeIntegrations();
@@ -4229,12 +4556,16 @@ class StructurizrDSLGenerator {
       handlersByType.get(handler.messageType)?.push(handler);
     }
     for (const [messageType, handlers] of handlersByType) {
-      const componentName = this.toComponentName(messageType);
       const firstHandler = handlers[0];
       if (!firstHandler)
         continue;
+      const isRest = firstHandler.handlerKind === "rest";
+      const componentName = isRest ? messageType : this.toComponentName(messageType);
       const description = this.generateComponentDescription(messageType, firstHandler);
       const tags = this.getComponentTags(messageType, firstHandler);
+      if (isRest) {
+        tags.push("REST Endpoint");
+      }
       const properties = this.getComponentProperties(messageType, firstHandler, contextType);
       componentDefs.push({
         id: this.toId(componentName),
@@ -5066,9 +5397,12 @@ class StructurizrDSLGenerator {
       popup: "Browser Action Popup",
       devtools: "DevTools Panel",
       options: "Options Page",
-      offscreen: "Offscreen Document"
+      offscreen: "Offscreen Document",
+      server: "Server Application",
+      client: "Client Application",
+      shared: "Shared Library"
     };
-    return technologies[contextType] || "Extension Context";
+    return technologies[contextType] || "Application Context";
   }
   toComponentName(messageType) {
     return `${messageType.split("_").map((part) => this.capitalize(part.toLowerCase())).join(" ")} Handler`;
@@ -5718,4 +6052,4 @@ main().catch((_error) => {
   process.exit(1);
 });
 
-//# debugId=6E19C4E7D7F05D9564756E2164756E21
+//# debugId=345DE519CB00B03D64756E2164756E21