arcvision 0.2.2 → 0.2.4

package/dist/index.js

@@ -4582,6 +4582,124 @@ var require_source = __commonJS({
   }
 });
 
+// src/core/tsconfig-utils.js
+var require_tsconfig_utils = __commonJS({
+  "src/core/tsconfig-utils.js"(exports2, module2) {
+    var fs2 = require("fs");
+    var path2 = require("path");
+    function loadTSConfig(startDir) {
+      let currentDir = startDir;
+      const root = path2.parse(currentDir).root;
+      while (currentDir) {
+        const tsconfigPaths = [
+          path2.join(currentDir, "tsconfig.json"),
+          path2.join(currentDir, "jsconfig.json")
+        ];
+        for (const tsconfigPath of tsconfigPaths) {
+          if (fs2.existsSync(tsconfigPath)) {
+            try {
+              let content = fs2.readFileSync(tsconfigPath, "utf-8");
+              if (content.charCodeAt(0) === 65279)
+                content = content.slice(1);
+              let parsed = null;
+              try {
+                parsed = JSON.parse(content);
+              } catch (e) {
+                const stripped = content.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1").replace(/,\s*([\]}])/g, "$1");
+                parsed = JSON.parse(stripped);
+              }
+              if (parsed) {
+                return {
+                  options: parsed.compilerOptions || {},
+                  configDir: currentDir
+                };
+              }
+            } catch (error) {
+              console.warn(`Warning: Could not parse ${tsconfigPath}:`, error.message);
+            }
+          }
+        }
+        if (currentDir === root)
+          break;
+        currentDir = path2.dirname(currentDir);
+      }
+      return { options: null, configDir: startDir };
+    }
+    module2.exports = { loadTSConfig };
+  }
+});
+
+// src/core/workspace-scanner.js
+var require_workspace_scanner = __commonJS({
+  "src/core/workspace-scanner.js"(exports2, module2) {
+    var fs2 = require("fs");
+    var path2 = require("path");
+    var { loadTSConfig } = require_tsconfig_utils();
+    var WorkspaceScanner = class {
+      constructor(rootPath) {
+        this.rootPath = path2.resolve(rootPath);
+        this.workspaceMap = /* @__PURE__ */ new Map();
+        this.tsconfigMap = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Performs the scan and returns the context.
+       * @returns {Object} { workspaceMap, tsconfigMap }
+       */
+      scan() {
+        console.log(`Starting workspace scan at ${this.rootPath}`);
+        this._scanRecursively(this.rootPath);
+        const sortedWorkspaceMap = new Map([...this.workspaceMap.entries()].sort());
+        const sortedTsconfigMap = new Map([...this.tsconfigMap.entries()].sort());
+        console.log(`Workspace scan complete. Found ${sortedWorkspaceMap.size} packages.`);
+        return {
+          workspaceMap: sortedWorkspaceMap,
+          tsconfigMap: sortedTsconfigMap
+        };
+      }
+      _scanRecursively(currentPath) {
+        let entries;
+        try {
+          entries = fs2.readdirSync(currentPath, { withFileTypes: true });
+        } catch (e) {
+          console.error(`Failed to read directory ${currentPath}: ${e.message}`);
+          return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        const tsConfig = loadTSConfig(currentPath);
+        if (tsConfig) {
+          this.tsconfigMap.set(currentPath, tsConfig);
+        }
+        for (const entry of entries) {
+          const fullPath = path2.join(currentPath, entry.name);
+          if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+              continue;
+            }
+            this._scanRecursively(fullPath);
+          } else if (entry.name === "package.json") {
+            this._processPackageJson(fullPath);
+          }
+        }
+      }
+      _processPackageJson(packageJsonPath) {
+        try {
+          const content = fs2.readFileSync(packageJsonPath, "utf-8");
+          const pkg = JSON.parse(content);
+          if (pkg.name) {
+            if (this.workspaceMap.has(pkg.name)) {
+            } else {
+              this.workspaceMap.set(pkg.name, path2.dirname(packageJsonPath));
+            }
+          }
+        } catch (e) {
+          console.warn(`Failed to parse package.json at ${packageJsonPath}: ${e.message}`);
+        }
+      }
+    };
+    module2.exports = { WorkspaceScanner };
+  }
+});
+
 // node_modules/balanced-match/index.js
 var require_balanced_match = __commonJS({
   "node_modules/balanced-match/index.js"(exports2, module2) {
@@ -56320,12 +56438,15 @@ var require_parser = __commonJS({
       }
       const metadata = {
         id: filePath,
+        ast,
+        // Include AST for enhanced analyzers
         imports: [],
         exports: [],
         functions: [],
         apiCalls: [],
         classes: [],
         variables: [],
+        types: [],
         dependencies: []
       };
       traverse(ast, {
@@ -56419,6 +56540,18 @@ var require_parser = __commonJS({
                   });
                 }
               });
+            } else if (node.declaration.type === "TSInterfaceDeclaration" && node.declaration.id) {
+              metadata.exports.push({
+                name: node.declaration.id.name,
+                type: "interface",
+                loc: node.declaration.loc
+              });
+            } else if (node.declaration.type === "TSTypeAliasDeclaration" && node.declaration.id) {
+              metadata.exports.push({
+                name: node.declaration.id.name,
+                type: "type",
+                loc: node.declaration.loc
+              });
             }
           }
         },
@@ -56472,13 +56605,30 @@ var require_parser = __commonJS({
             });
           }
         },
-        ArrowFunctionExpression({ node }) {
+        ArrowFunctionExpression(path3) {
+          const parent = path3.parent;
+          if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+            metadata.functions.push({
+              name: parent.id.name,
+              params: path3.node.params.map((p) => p.name || "?"),
+              loc: parent.loc
+            });
+          }
+        },
+        TSInterfaceDeclaration({ node }) {
+          if (node.id && node.id.name) {
+            metadata.types.push({
+              name: node.id.name,
+              kind: "interface",
+              loc: node.loc
+            });
+          }
         },
-        ClassDeclaration({ node }) {
+        TSTypeAliasDeclaration({ node }) {
           if (node.id && node.id.name) {
-            metadata.classes.push({
+            metadata.types.push({
               name: node.id.name,
-              superClass: node.superClass ? node.superClass.name : null,
+              kind: "type",
               loc: node.loc
             });
           }
@@ -56486,11 +56636,23 @@ var require_parser = __commonJS({
         VariableDeclaration({ node }) {
           node.declarations.forEach((decl) => {
             if (decl.id.name) {
-              metadata.variables.push({
+              const variableData = {
                 name: decl.id.name,
                 type: "variable",
                 loc: decl.loc
-              });
+              };
+              if (decl.init && decl.init.type === "ObjectExpression") {
+                variableData.properties = decl.init.properties.map((p) => {
+                  if (p.key && (p.key.name || p.key.value)) {
+                    return {
+                      name: p.key.name || p.key.value,
+                      loc: p.loc
+                    };
+                  }
+                  return null;
+                }).filter(Boolean);
+              }
+              metadata.variables.push(variableData);
             } else if (decl.id.type === "ObjectPattern") {
               decl.id.properties.forEach((prop) => {
                 if (prop.key && prop.key.name) {
@@ -56553,9 +56715,27 @@ var require_parser = __commonJS({
         },
         VariableDeclarator({ node }) {
           if (node.init && node.init.type === "CallExpression" && node.init.callee.name === "require" && node.init.arguments.length > 0 && node.init.arguments[0].type === "StringLiteral") {
+            const specifiers = [];
+            if (node.id.type === "ObjectPattern") {
+              node.id.properties.forEach((prop) => {
+                const importedName = prop.key && (prop.key.name || prop.key.value) || null;
+                const localName = prop.value && prop.value.name || importedName;
+                if (importedName) {
+                  specifiers.push({
+                    imported: importedName,
+                    local: localName
+                  });
+                }
+              });
+            } else if (node.id.type === "Identifier") {
+              specifiers.push({
+                imported: "default",
+                local: node.id.name
+              });
+            }
             metadata.imports.push({
               source: node.init.arguments[0].value,
-              specifiers: [],
+              specifiers,
               type: "require-assignment"
             });
           }
@@ -56569,6 +56749,688 @@ var require_parser = __commonJS({
   }
 });
 
+// src/core/di-detector.js
+var require_di_detector = __commonJS({
+  "src/core/di-detector.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function detectConstructorInjection(ast) {
+      const injections = [];
+      traverse(ast, {
+        ClassDeclaration(path2) {
+          const className = path2.node.id ? path2.node.id.name : "Anonymous";
+          const constructor = path2.node.body.body.find(
+            (member) => member.kind === "constructor"
+          );
+          if (constructor && constructor.params) {
+            constructor.params.forEach((param) => {
+              let paramName = null;
+              let paramType = null;
+              if (param.type === "TSParameterProperty") {
+                if (param.parameter.type === "Identifier") {
+                  paramName = param.parameter.name;
+                  if (param.parameter.typeAnnotation) {
+                    paramType = extractTypeName(param.parameter.typeAnnotation);
+                  }
+                }
+              } else if (param.type === "Identifier") {
+                paramName = param.name;
+                if (param.typeAnnotation) {
+                  paramType = extractTypeName(param.typeAnnotation);
+                }
+              }
+              if (paramName) {
+                injections.push({
+                  className,
+                  paramName,
+                  paramType,
+                  pattern: "constructor_injection",
+                  loc: constructor.loc
+                });
+              }
+            });
+          }
+        }
+      });
+      return injections;
+    }
+    function detectReactContextUsage(ast) {
+      const contextUsages = [];
+      traverse(ast, {
+        // Detect useContext hook calls
+        CallExpression(path2) {
+          if (path2.node.callee.name === "useContext" && path2.node.arguments.length > 0) {
+            const contextArg = path2.node.arguments[0];
+            let contextName = null;
+            if (contextArg.type === "Identifier") {
+              contextName = contextArg.name;
+            } else if (contextArg.type === "MemberExpression") {
+              contextName = extractMemberExpressionName(contextArg);
+            }
+            if (contextName) {
+              contextUsages.push({
+                type: "useContext",
+                contextName,
+                pattern: "context_consumer",
+                loc: path2.node.loc
+              });
+            }
+          }
+        },
+        // Detect Context.Provider usage in JSX
+        JSXElement(path2) {
+          const openingElement = path2.node.openingElement;
+          if (openingElement.name.type === "JSXMemberExpression") {
+            const objectName = openingElement.name.object.name;
+            const propertyName = openingElement.name.property.name;
+            if (propertyName === "Provider" || propertyName === "Consumer") {
+              contextUsages.push({
+                type: "JSXProvider",
+                contextName: objectName,
+                pattern: propertyName === "Provider" ? "context_provider" : "context_consumer",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return contextUsages;
+    }
+    function detectHookDependencies(ast) {
+      const hookDeps = [];
+      traverse(ast, {
+        CallExpression(path2) {
+          const calleeName = path2.node.callee.name;
+          if (calleeName && calleeName.startsWith("use") && calleeName !== "useContext") {
+            hookDeps.push({
+              hookName: calleeName,
+              pattern: "custom_hook",
+              loc: path2.node.loc
+            });
+          }
+        }
+      });
+      return hookDeps;
+    }
+    function detectDependencyInjection(ast) {
+      if (!ast) {
+        return {
+          constructorInjections: [],
+          contextUsages: [],
+          hookDependencies: []
+        };
+      }
+      return {
+        constructorInjections: detectConstructorInjection(ast),
+        contextUsages: detectReactContextUsage(ast),
+        hookDependencies: detectHookDependencies(ast)
+      };
+    }
+    function extractTypeName(typeAnnotation) {
+      if (!typeAnnotation)
+        return null;
+      const annotation = typeAnnotation.typeAnnotation || typeAnnotation;
+      if (annotation.type === "TSTypeReference" && annotation.typeName) {
+        if (annotation.typeName.type === "Identifier") {
+          return annotation.typeName.name;
+        }
+      }
+      return null;
+    }
+    function extractMemberExpressionName(node) {
+      if (node.type === "MemberExpression") {
+        const object = node.object.name || "";
+        const property = node.property.name || "";
+        return object + "." + property;
+      }
+      return null;
+    }
+    module2.exports = {
+      detectConstructorInjection,
+      detectReactContextUsage,
+      detectHookDependencies,
+      detectDependencyInjection
+    };
+  }
+});
+
+// src/core/method-tracker.js
+var require_method_tracker = __commonJS({
+  "src/core/method-tracker.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function trackMethodCalls(ast, imports = []) {
+      const functionCalls = [];
+      const methodCalls = [];
+      const constructorCalls = [];
+      if (!ast) {
+        return { functionCalls, methodCalls, constructorCalls };
+      }
+      const importedSymbols = /* @__PURE__ */ new Set();
+      imports.forEach((imp) => {
+        if (imp.specifiers && Array.isArray(imp.specifiers)) {
+          imp.specifiers.forEach((spec) => {
+            const localName = spec.local || spec.imported || spec;
+            if (typeof localName === "string") {
+              importedSymbols.add(localName);
+            }
+          });
+        }
+      });
+      traverse(ast, {
+        CallExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "Identifier") {
+            const functionName = callee.name;
+            functionCalls.push({
+              name: functionName,
+              type: "function_call",
+              loc: path2.node.loc
+            });
+          } else if (callee.type === "MemberExpression") {
+            const objectName = extractObjectName(callee.object);
+            const methodName = callee.property.name || callee.property.value;
+            if (objectName && methodName) {
+              methodCalls.push({
+                object: objectName,
+                method: methodName,
+                type: "method_call",
+                loc: path2.node.loc
+              });
+            }
+          }
+        },
+        // Track constructor calls: new ClassName()
+        NewExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "Identifier") {
+            const className = callee.name;
+            constructorCalls.push({
+              className,
+              type: "constructor_call",
+              loc: path2.node.loc
+            });
+          }
+        }
+      });
+      return {
+        functionCalls,
+        methodCalls,
+        constructorCalls
+      };
+    }
+    function buildCallGraph(nodes) {
+      const callEdges = [];
+      nodes.forEach((node) => {
+        const filePath = node.id;
+        const metadata = node.metadata;
+        if (!metadata)
+          return;
+        if (metadata.functionCalls && Array.isArray(metadata.functionCalls)) {
+          metadata.functionCalls.forEach((call) => {
+            callEdges.push({
+              source: filePath,
+              callType: "function",
+              calledSymbol: call.name,
+              loc: call.loc
+            });
+          });
+        }
+        if (metadata.constructorCalls && Array.isArray(metadata.constructorCalls)) {
+          metadata.constructorCalls.forEach((call) => {
+            callEdges.push({
+              source: filePath,
+              callType: "constructor",
+              calledSymbol: call.className,
+              loc: call.loc
+            });
+          });
+        }
+        if (metadata.methodCalls && Array.isArray(metadata.methodCalls)) {
+          metadata.methodCalls.forEach((call) => {
+            callEdges.push({
+              source: filePath,
+              callType: "method",
+              calledSymbol: `${call.object}.${call.method}`,
+              loc: call.loc
+            });
+          });
+        }
+      });
+      return callEdges;
+    }
+    function extractObjectName(node) {
+      if (node.type === "Identifier") {
+        return node.name;
+      } else if (node.type === "ThisExpression") {
+        return "this";
+      } else if (node.type === "MemberExpression") {
+        const object = extractObjectName(node.object);
+        const property = node.property.name || node.property.value;
+        return object && property ? `${object}.${property}` : object;
+      }
+      return null;
+    }
+    module2.exports = {
+      trackMethodCalls,
+      buildCallGraph
+    };
+  }
+});
+
+// src/core/type-analyzer.js
+var require_type_analyzer = __commonJS({
+  "src/core/type-analyzer.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function extractTypeImports(ast) {
+      const typeImports = [];
+      if (!ast)
+        return typeImports;
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const node = path2.node;
+          if (node.importKind === "type") {
+            const specifiers = [];
+            node.specifiers.forEach((spec) => {
+              if (spec.imported) {
+                specifiers.push({
+                  imported: spec.imported.name || spec.imported.value,
+                  local: spec.local.name
+                });
+              }
+            });
+            typeImports.push({
+              source: node.source.value,
+              specifiers,
+              importKind: "type",
+              loc: node.loc
+            });
+          } else {
+            const typeSpecifiers = [];
+            node.specifiers.forEach((spec) => {
+              if (spec.importKind === "type" && spec.imported) {
+                typeSpecifiers.push({
+                  imported: spec.imported.name || spec.imported.value,
+                  local: spec.local.name
+                });
+              }
+            });
+            if (typeSpecifiers.length > 0) {
+              typeImports.push({
+                source: node.source.value,
+                specifiers: typeSpecifiers,
+                importKind: "mixed",
+                loc: node.loc
+              });
+            }
+          }
+        }
+      });
+      return typeImports;
+    }
+    function extractInterfaceDependencies(ast) {
+      const interfaceDeps = [];
+      if (!ast)
+        return interfaceDeps;
+      traverse(ast, {
+        // Interface extends
+        TSInterfaceDeclaration(path2) {
+          const node = path2.node;
+          const interfaceName = node.id.name;
+          if (node.extends && node.extends.length > 0) {
+            node.extends.forEach((ext) => {
+              const extendedInterface = extractTypeName(ext.expression);
+              if (extendedInterface) {
+                interfaceDeps.push({
+                  interface: interfaceName,
+                  extends: extendedInterface,
+                  type: "interface_extends",
+                  loc: node.loc
+                });
+              }
+            });
+          }
+        },
+        // Class implements
+        ClassDeclaration(path2) {
+          const node = path2.node;
+          const className = node.id ? node.id.name : "Anonymous";
+          if (node.implements && node.implements.length > 0) {
+            node.implements.forEach((impl) => {
+              const implementedInterface = extractTypeName(impl.expression);
+              if (implementedInterface) {
+                interfaceDeps.push({
+                  class: className,
+                  implements: implementedInterface,
+                  type: "class_implements",
+                  loc: node.loc
+                });
+              }
+            });
+          }
+        }
+      });
+      return interfaceDeps;
+    }
+    function extractGenericDependencies(ast) {
+      const genericDeps = [];
+      if (!ast)
+        return genericDeps;
+      traverse(ast, {
+        // Function return types
+        FunctionDeclaration(path2) {
+          const node = path2.node;
+          const functionName = node.id ? node.id.name : "anonymous";
+          if (node.returnType) {
+            const returnTypeName = extractComplexTypeName(node.returnType.typeAnnotation);
+            if (returnTypeName) {
+              genericDeps.push({
+                function: functionName,
+                returnType: returnTypeName,
+                type: "return_type",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Arrow function return types
+        ArrowFunctionExpression(path2) {
+          const node = path2.node;
+          if (node.returnType) {
+            const returnTypeName = extractComplexTypeName(node.returnType.typeAnnotation);
+            if (returnTypeName) {
+              genericDeps.push({
+                function: "arrow_function",
+                returnType: returnTypeName,
+                type: "return_type",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Variable type annotations
+        VariableDeclarator(path2) {
+          const node = path2.node;
+          const varName = node.id.name;
+          if (node.id.typeAnnotation) {
+            const typeName = extractComplexTypeName(node.id.typeAnnotation.typeAnnotation);
+            if (typeName) {
+              genericDeps.push({
+                variable: varName,
+                type: typeName,
+                kind: "variable_type",
+                loc: node.loc
+              });
+            }
+          }
+        }
+      });
+      return genericDeps;
+    }
+    function analyzeTypeDependencies(ast) {
+      if (!ast) {
+        return {
+          typeImports: [],
+          interfaceDependencies: [],
+          genericDependencies: []
+        };
+      }
+      return {
+        typeImports: extractTypeImports(ast),
+        interfaceDependencies: extractInterfaceDependencies(ast),
+        genericDependencies: extractGenericDependencies(ast)
+      };
+    }
+    function extractTypeName(node) {
+      if (!node)
+        return null;
+      if (node.type === "Identifier") {
+        return node.name;
+      } else if (node.type === "TSTypeReference" && node.typeName) {
+        if (node.typeName.type === "Identifier") {
+          return node.typeName.name;
+        }
+      }
+      return null;
+    }
+    function extractComplexTypeName(node) {
+      if (!node)
+        return null;
+      if (node.type === "TSTypeReference" && node.typeName) {
+        let baseName = extractTypeName(node);
+        if (node.typeParameters && node.typeParameters.params) {
+          const params = node.typeParameters.params.map((p) => extractComplexTypeName(p)).filter(Boolean).join(", ");
+          if (params) {
+            baseName += `<${params}>`;
+          }
+        }
+        return baseName;
+      } else if (node.type === "Identifier") {
+        return node.name;
+      } else if (node.type === "TSArrayType") {
+        const elementType = extractComplexTypeName(node.elementType);
+        return elementType ? `${elementType}[]` : null;
+      }
+      return null;
+    }
+    module2.exports = {
+      extractTypeImports,
+      extractInterfaceDependencies,
+      extractGenericDependencies,
+      analyzeTypeDependencies
+    };
+  }
+});
+
+// src/core/react-nextjs-detector.js
+var require_react_nextjs_detector = __commonJS({
+  "src/core/react-nextjs-detector.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function detectComponentUsage(ast) {
+      const componentUsages = [];
+      if (!ast)
+        return componentUsages;
+      traverse(ast, {
+        JSXElement(path2) {
+          const openingElement = path2.node.openingElement;
+          let componentName = null;
+          if (openingElement.name.type === "JSXIdentifier") {
+            componentName = openingElement.name.name;
+            if (/^[A-Z]/.test(componentName)) {
+              componentUsages.push({
+                component: componentName,
+                type: "jsx_component",
+                loc: path2.node.loc
+              });
+            }
+          } else if (openingElement.name.type === "JSXMemberExpression") {
+            const object = openingElement.name.object.name;
+            const property = openingElement.name.property.name;
+            componentName = `${object}.${property}`;
+            componentUsages.push({
+              component: componentName,
+              type: "jsx_member_component",
+              loc: path2.node.loc
+            });
+          }
+        }
+      });
+      return componentUsages;
+    }
+    function detectServerClientBoundaries(content) {
+      const boundaries = {
+        isClientComponent: false,
+        isServerComponent: false,
+        isServerAction: false
+      };
+      if (!content)
+        return boundaries;
+      if (/['"]use client['"]/.test(content)) {
+        boundaries.isClientComponent = true;
+      }
+      if (/['"]use server['"]/.test(content)) {
+        boundaries.isServerAction = true;
+      }
+      if (!boundaries.isClientComponent && !boundaries.isServerAction) {
+        boundaries.isServerComponent = true;
+      }
+      return boundaries;
+    }
+    function detectAPIRouteDependencies(ast) {
+      const apiDeps = [];
+      if (!ast)
+        return apiDeps;
+      traverse(ast, {
+        // Detect Next.js API route handlers: export async function GET/POST/etc
+        ExportNamedDeclaration(path2) {
+          const node = path2.node;
+          if (node.declaration && node.declaration.type === "FunctionDeclaration") {
+            const funcName = node.declaration.id ? node.declaration.id.name : null;
+            if (["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"].includes(funcName)) {
+              apiDeps.push({
+                handler: funcName,
+                type: "api_route_handler",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Detect fetch calls and database queries within API routes
+        CallExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "MemberExpression") {
+            const objectName = callee.object.name;
+            const methodName = callee.property.name || callee.property.value;
+            if (objectName === "supabase" || /supabase/i.test(objectName)) {
+              apiDeps.push({
+                service: "supabase",
+                method: methodName,
+                type: "database_query",
+                loc: path2.node.loc
+              });
+            }
+            if (objectName === "prisma" || /prisma/i.test(objectName)) {
+              apiDeps.push({
+                service: "prisma",
+                method: methodName,
+                type: "database_query",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return apiDeps;
+    }
+    function detectMiddlewareDependencies(ast, filePath = "") {
+      const middlewareDeps = [];
+      const isMiddleware = /middleware\.(ts|js)$/.test(filePath);
+      if (!isMiddleware || !ast)
+        return middlewareDeps;
+      traverse(ast, {
+        // Detect middleware function export
+        ExportNamedDeclaration(path2) {
+          const node = path2.node;
+          if (node.declaration && node.declaration.type === "FunctionDeclaration") {
+            const funcName = node.declaration.id ? node.declaration.id.name : null;
+            if (funcName === "middleware") {
+              middlewareDeps.push({
+                function: funcName,
+                type: "middleware_function",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Detect auth checks and redirects
+        CallExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "MemberExpression") {
+            const methodName = callee.property.name || callee.property.value;
+            if (methodName === "getUser" || methodName === "getSession") {
+              middlewareDeps.push({
+                service: "auth",
+                method: methodName,
+                type: "auth_check",
+                loc: path2.node.loc
+              });
+            }
+            if (methodName === "redirect" || methodName === "rewrite") {
+              middlewareDeps.push({
+                service: "next",
+                method: methodName,
+                type: "middleware_action",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return middlewareDeps;
+    }
+    function detectReactNextJSPatterns(ast, content = "", filePath = "") {
+      return {
+        componentUsages: detectComponentUsage(ast),
+        boundaries: detectServerClientBoundaries(content),
+        apiDependencies: detectAPIRouteDependencies(ast),
+        middlewareDependencies: detectMiddlewareDependencies(ast, filePath)
+      };
+    }
+    module2.exports = {
+      detectComponentUsage,
+      detectServerClientBoundaries,
+      detectAPIRouteDependencies,
+      detectMiddlewareDependencies,
+      detectReactNextJSPatterns
+    };
+  }
+});
+
+// src/core/parser-enhanced.js
+var require_parser_enhanced = __commonJS({
+  "src/core/parser-enhanced.js"(exports2, module2) {
+    var { parseFile: originalParseFile } = require_parser();
+    var { detectDependencyInjection } = require_di_detector();
+    var { trackMethodCalls } = require_method_tracker();
+    var { analyzeTypeDependencies } = require_type_analyzer();
+    var { detectReactNextJSPatterns } = require_react_nextjs_detector();
+    var fs2 = require("fs");
+    function parseFileEnhanced(filePath) {
+      const metadata = originalParseFile(filePath);
+      if (!metadata.ast) {
+        return metadata;
+      }
+      const ast = metadata.ast;
+      const fileContent = fs2.readFileSync(filePath, "utf-8");
+      try {
+        const diPatterns = detectDependencyInjection(ast);
+        metadata.constructorInjections = diPatterns.constructorInjections || [];
+        metadata.contextUsages = diPatterns.contextUsages || [];
+        metadata.hookDependencies = diPatterns.hookDependencies || [];
+        const callTracking = trackMethodCalls(ast, metadata.imports);
+        metadata.functionCalls = callTracking.functionCalls || [];
+        metadata.constructorCalls = callTracking.constructorCalls || [];
+        metadata.methodCalls = callTracking.methodCalls || [];
+        const typeDeps = analyzeTypeDependencies(ast);
+        metadata.typeImports = typeDeps.typeImports || [];
+        metadata.interfaceDependencies = typeDeps.interfaceDependencies || [];
+        metadata.genericDependencies = typeDeps.genericDependencies || [];
+        const reactPatterns = detectReactNextJSPatterns(ast, fileContent, filePath);
+        metadata.componentUsage = reactPatterns.componentUsages || [];
+        metadata.serverClientBoundaries = reactPatterns.boundaries || {};
+        metadata.apiDependencies = reactPatterns.apiDependencies || [];
+        metadata.middlewareDependencies = reactPatterns.middlewareDependencies || [];
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F Enhanced analysis failed for ${filePath}: ${error.message}`);
+      }
+      delete metadata.ast;
+      return metadata;
+    }
+    module2.exports = {
+      parseFile: parseFileEnhanced,
+      parseFileBasic: originalParseFile
+    };
+  }
+});
+
 // src/plugins/plugin-manager.js
 var require_plugin_manager = __commonJS({
   "src/plugins/plugin-manager.js"(exports2, module2) {
@@ -56624,34 +57486,96 @@ var require_plugin_manager = __commonJS({
   }
 });
 
-// src/core/tsconfig-utils.js
-var require_tsconfig_utils = __commonJS({
-  "src/core/tsconfig-utils.js"(exports2, module2) {
-    var fs2 = require("fs");
+// src/engine/pass1_facts.js
+var require_pass1_facts = __commonJS({
+  "src/engine/pass1_facts.js"(exports2, module2) {
+    var { glob } = require_commonjs5();
     var path2 = require("path");
-    function loadTSConfig(projectRoot) {
-      const tsconfigPaths = [
-        path2.join(projectRoot, "tsconfig.json"),
-        path2.join(projectRoot, "jsconfig.json")
-      ];
-      for (const tsconfigPath of tsconfigPaths) {
-        if (fs2.existsSync(tsconfigPath)) {
-          try {
-            let content = fs2.readFileSync(tsconfigPath, "utf-8");
-            if (content.charCodeAt(0) === 65279) {
-              content = content.slice(1);
+    var fs2 = require("fs");
+    var parser = require_parser_enhanced();
+    var pluginManager = require_plugin_manager();
+    async function executePass1(directory, options = {}) {
+      console.log("\u{1F9F1} PASS 1: Syntactic Fact Extraction...");
+      const normalize = (p) => p.replace(/\\/g, "/");
+      const scanOptions = {
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", ...options.ignore || []],
+        cwd: directory,
+        absolute: true
+      };
+      const pluginDir = path2.join(__dirname, "../plugins");
+      if (fs2.existsSync(pluginDir)) {
+        pluginManager.loadPluginsFromDirectory(pluginDir);
+      }
+      const files = await glob("**/*.{js,jsx,ts,tsx,json}", {
+        ...scanOptions,
+        ignore: [...scanOptions.ignore, "**/*.d.ts", "**/.next/**", "**/coverage/**", "**/arcvision.context.json"]
+      });
+      const rawNodes = [];
+      let totalFacts = 0;
+      for (const file of files) {
+        try {
+          const relativePath = path2.relative(directory, file);
+          const normalizedRelativePath = normalize(relativePath);
+          let metadata = {};
+          if (file.endsWith(".json")) {
+            try {
+              const content = fs2.readFileSync(file, "utf-8");
+              JSON.parse(content);
+              metadata = {
+                id: file,
+                isJson: true,
+                // JSONs might have "imports" in semantic sense (like package.json), but raw syntax is just data
+                raw: content
+              };
+            } catch (e) {
+              console.warn(`\u26A0\uFE0F Invalid JSON in ${normalizedRelativePath}: ${e.message}`);
+              continue;
             }
-            const raw = JSON.parse(content);
-            return raw.compilerOptions || {};
-          } catch (error) {
-            console.warn(`Warning: Could not parse ${tsconfigPath}:`, error.message);
-            return null;
-          }
+          } else {
+            metadata = parser.parseFile(file);
+          }
+          metadata = await pluginManager.processFile(file, metadata);
+          const node = {
+            id: normalizedRelativePath,
+            // Unique ID for this pass
+            filePath: file,
+            type: "file",
+            // The "facts" are the metadata properties
+            facts: {
+              imports: metadata.imports || [],
+              exports: metadata.exports || [],
+              functions: metadata.functions || [],
+              classes: metadata.classes || [],
+              types: metadata.types || [],
+              calls: {
+                functions: metadata.functionCalls || [],
+                methods: metadata.methodCalls || [],
+                constructors: metadata.constructorCalls || []
+              },
+              typeAnalysis: {
+                typeImports: metadata.typeImports || [],
+                interfaceDeps: metadata.interfaceDependencies || [],
+                genericDeps: metadata.genericDependencies || []
+              },
+              di: {
+                injections: metadata.constructorInjections || [],
+                hooks: metadata.hookDependencies || [],
+                context: metadata.contextUsages || []
+              },
+              react: metadata.componentUsage || []
+            }
+          };
+          totalFacts += (metadata.imports?.length || 0) + (metadata.functionCalls?.length || 0);
+          rawNodes.push(node);
+        } catch (e) {
+          console.warn(`\u26A0\uFE0F Pass 1 failed for ${file}: ${e.message}`);
         }
       }
-      return null;
+      console.log(`   \u2713 Scanned ${rawNodes.length} files`);
+      console.log(`   \u2713 Extracted ${totalFacts} raw syntactic facts`);
+      return rawNodes;
     }
-    module2.exports = { loadTSConfig };
+    module2.exports = { executePass1 };
   }
 });
 
@@ -56660,7 +57584,7 @@ var require_path_resolver = __commonJS({
   "src/core/path-resolver.js"(exports2, module2) {
     var fs2 = require("fs");
     var path2 = require("path");
-    function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
+    function resolveImport(importPath, importerPath, projectRoot, tsconfig, workspaceMap) {
       if (importPath.startsWith("http://") || importPath.startsWith("https://") || importPath.startsWith("data:") || importPath.startsWith("file:")) {
         return null;
       }
@@ -56691,8 +57615,8 @@ var require_path_resolver = __commonJS({
           const aliasTargets = paths[aliasPattern];
           if (aliasPattern.includes("*")) {
             const patternBase = aliasPattern.replace(/\*.*$/, "");
-            if (importPath.startsWith(patternBase)) {
-              const suffix = importPath.substring(patternBase.length);
+            if (importPath === patternBase.slice(0, -1) || importPath.startsWith(patternBase)) {
+              const suffix = importPath.length >= patternBase.length ? importPath.substring(patternBase.length) : "";
               for (const target of aliasTargets) {
                 const targetBase = target.replace(/\*.*$/, "");
                 const targetPath = path2.resolve(projectRoot, path2.join(targetBase, suffix));
@@ -56762,6 +57686,51 @@ var require_path_resolver = __commonJS({
           return resolvedPath;
         }
       }
+      if (workspaceMap && workspaceMap.has(importPath)) {
+        const packageRoot = workspaceMap.get(importPath);
+        try {
+          const pkgPath = path2.join(packageRoot, "package.json");
+          if (fs2.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+            const mainFile = pkg.main || pkg.module || "index.js";
+            const searchPath = path2.join(packageRoot, mainFile);
+            const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+            for (const ext of extensions) {
+              const p = searchPath + ext;
+              if (fs2.existsSync(p))
+                return p;
+            }
+          }
+          const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+          for (const idx of indexFiles) {
+            const p = path2.join(packageRoot, idx);
+            if (fs2.existsSync(p))
+              return p;
+          }
+        } catch (e) {
+        }
+        return packageRoot;
+      }
+      if (workspaceMap) {
+        for (const [pkgName, pkgRoot] of workspaceMap.entries()) {
+          if (importPath.startsWith(pkgName + "/")) {
+            const suffix = importPath.substring(pkgName.length + 1);
+            const targetPath = path2.join(pkgRoot, suffix);
+            const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ""];
+            for (const ext of extensions) {
+              if (fs2.existsSync(targetPath + ext)) {
+                return targetPath + ext;
+              }
+            }
+            const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+            for (const idx of indexFiles) {
+              const p = path2.join(targetPath, idx);
+              if (fs2.existsSync(p))
+                return p;
+            }
+          }
+        }
+      }
       if (!importPath.startsWith(".")) {
         try {
           const resolved = require.resolve(importPath, { paths: [path2.dirname(importerPath)] });
@@ -56775,6 +57744,509 @@ var require_path_resolver = __commonJS({
   }
 });
 
+// src/core/symbol-indexer.js
+var require_symbol_indexer = __commonJS({
+  "src/core/symbol-indexer.js"(exports2, module2) {
+    var crypto = require("crypto");
+    var SymbolIndexer = class {
+      constructor() {
+        this.symbols = /* @__PURE__ */ new Map();
+        this.fileToSymbols = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Build symbol index from raw files
+       * @param {Array<Object>} rawFiles - List of files with metadata from parser
+       * @returns {Object} { symbols, fileToSymbols }
+       */
+      index(rawFiles) {
+        console.log(`Indexing symbols for ${rawFiles.length} files...`);
+        this.reExports = /* @__PURE__ */ new Map();
+        const sortedFiles = [...rawFiles].sort((a, b) => a.id.localeCompare(b.id));
+        for (const file of sortedFiles) {
+          if (!file.metadata)
+            continue;
+          this._indexFile(file);
+        }
+        this._propagateReExports();
+        console.log(`Indexed ${this.symbols.size} symbols.`);
+        return {
+          symbols: this.symbols,
+          fileToSymbols: this.fileToSymbols
+        };
+      }
+      _indexFile(file) {
+        const fileId = file.id;
+        const metadata = file.metadata;
+        const addSymbol = (name, kind, exported = false, loc = null) => {
+          const id = `${fileId}::${name}`;
+          const symbol = { id, name, kind, fileId, exported, loc };
+          this.symbols.set(id, symbol);
+          if (!this.fileToSymbols.has(fileId)) {
+            this.fileToSymbols.set(fileId, /* @__PURE__ */ new Set());
+          }
+          this.fileToSymbols.get(fileId).add(id);
+          return symbol;
+        };
+        if (metadata.exports) {
+          metadata.exports.forEach((exp) => {
+            addSymbol(exp.name, exp.type || "variable", true, exp.loc);
+            if (exp.type === "default" && exp.name !== "default") {
+              addSymbol("default", "default", true, exp.loc);
+            }
+          });
+        }
+        if (metadata.functions) {
+          metadata.functions.forEach((func) => {
+            const id = `${fileId}::${func.name}`;
+            if (!this.symbols.has(id)) {
+              addSymbol(func.name, "function", false, func.loc);
+            } else {
+              const sym = this.symbols.get(id);
+              if (sym.kind === "variable")
+                sym.kind = "function";
+            }
+          });
+        }
+        if (metadata.imports) {
+          metadata.imports.forEach((imp) => {
+            if (imp.type === "export-all" && imp.resolvedPath) {
+              if (!this.reExports.has(fileId))
+                this.reExports.set(fileId, /* @__PURE__ */ new Set());
+              this.reExports.get(fileId).add(imp.resolvedPath);
+            }
+          });
+        }
+        if (metadata.classes) {
+          metadata.classes.forEach((c) => {
+            const id = `${fileId}::${c.name}`;
+            if (this.symbols.has(id)) {
+              this.symbols.get(id).kind = "class";
+            } else {
+              addSymbol(c.name, "class", false, c.loc);
+            }
+          });
+        }
+        if (metadata.types) {
+          metadata.types.forEach((t) => {
+            const id = `${fileId}::${t.name}`;
+            if (this.symbols.has(id)) {
+              this.symbols.get(id).kind = t.kind;
+            } else {
+              addSymbol(t.name, t.kind, false, t.loc);
+            }
+          });
+        }
+        if (metadata.variables) {
+          metadata.variables.forEach((v) => {
+            addSymbol(v.name, "variable", false, v.loc);
+            if (v.properties && v.properties.length > 0) {
+              v.properties.forEach((prop) => {
+                addSymbol(`${v.name}.${prop.name}`, "method", false, prop.loc);
+              });
+            }
+          });
+        }
+      }
+      _propagateReExports() {
+        const visited = /* @__PURE__ */ new Set();
+        const propagate = (fileId) => {
+          if (visited.has(fileId))
+            return;
+          visited.add(fileId);
+          const targets = this.reExports.get(fileId);
+          if (!targets)
+            return;
+          for (const targetPath of targets) {
+            propagate(targetPath);
+            const targetSymbolIds = this.fileToSymbols.get(targetPath);
+            if (targetSymbolIds) {
+              for (const symId of targetSymbolIds) {
+                const originalSym = this.symbols.get(symId);
+                if (originalSym && originalSym.exported) {
+                  const localId = `${fileId}::${originalSym.name}`;
+                  if (!this.symbols.has(localId)) {
+                    const newSym = { ...originalSym, id: localId, fileId };
+                    this.symbols.set(localId, newSym);
+                    if (!this.fileToSymbols.has(fileId))
+                      this.fileToSymbols.set(fileId, /* @__PURE__ */ new Set());
+                    this.fileToSymbols.get(fileId).add(localId);
+                  }
+                }
+              }
+            }
+          }
+        };
+        for (const fileId of this.reExports.keys()) {
+          propagate(fileId);
+        }
+      }
+    };
+    module2.exports = { SymbolIndexer };
+  }
+});
+
+// src/core/call-resolver.js
+var require_call_resolver = __commonJS({
+  "src/core/call-resolver.js"(exports2, module2) {
+    var CallResolver = class {
+      constructor(symbolIndex, fileMap) {
+        this.symbolIndex = symbolIndex;
+        this.fileMap = fileMap;
+      }
+      /**
+       * Resolve calls in all files
+       * @returns {Array<Object>} List of edges
+       */
+      resolve(rawFiles) {
+        const edges = [];
+        console.log(`Resolving calls for ${rawFiles.length} files...`);
+        for (const file of rawFiles) {
+          const fileEdges = this._resolveFile(file);
+          edges.push(...fileEdges);
+        }
+        console.log(`Resolved ${edges.length} call/instantiate edges.`);
+        return edges;
+      }
+      _resolveFile(file) {
+        const edges = [];
+        if (!file.methodCalls)
+          return edges;
+        const fileId = file.id;
+        const { functionCalls, constructorCalls, methodCalls } = file.methodCalls;
+        const imports = file.metadata.imports || [];
+        const resolveImportedSymbol = (symbolName) => {
+          for (const imp of imports) {
+            if (imp.specifiers) {
+              const spec = imp.specifiers.find((s) => s.local === symbolName);
+              if (spec) {
+                if (imp.resolvedPath) {
+                  const targetFileId = imp.resolvedPath;
+                  const targetSymbolName = spec.imported === "default" ? "default" : spec.imported;
+                  let candidateId = `${targetFileId}::${targetSymbolName}`;
+                  if (this.symbolIndex.has(candidateId))
+                    return candidateId;
+                  if (spec.imported === "default") {
+                    candidateId = `${targetFileId}::default`;
+                    if (this.symbolIndex.has(candidateId))
+                      return candidateId;
+                  }
+                }
+              }
+            }
+          }
+          const localId = `${fileId}::${symbolName}`;
+          if (this.symbolIndex.has(localId)) {
+            return localId;
+          }
+          return null;
+        };
+        if (functionCalls) {
+          for (const call of functionCalls) {
+            const targetSymbolId = resolveImportedSymbol(call.name);
+            if (targetSymbolId) {
+              edges.push({
+                sourceFileId: fileId,
+                targetSymbolId,
+                type: "CALLS",
+                line: call.loc ? call.loc.start.line : 0,
+                confidence: 1
+              });
+            }
+          }
+        }
+        if (constructorCalls) {
+          for (const call of constructorCalls) {
+            const targetSymbolId = resolveImportedSymbol(call.className);
+            if (targetSymbolId) {
+              edges.push({
+                sourceFileId: fileId,
+                targetSymbolId,
+                type: "INSTANTIATES",
+                line: call.loc ? call.loc.start.line : 0,
+                confidence: 1
+              });
+            }
+          }
+        }
+        if (methodCalls) {
+          for (const call of methodCalls) {
+            const imp = imports.find((i) => i.specifiers?.some((s) => s.local === call.object));
+            if (imp && imp.resolvedPath) {
+              const targetFileId = imp.resolvedPath;
+              const spec = imp.specifiers.find((s) => s.local === call.object);
+              const importedAs = spec ? spec.imported : null;
+              let candidateId = `${targetFileId}::${call.method}`;
+              if (this.symbolIndex.has(candidateId)) {
+                edges.push({
+                  sourceFileId: fileId,
+                  targetSymbolId: candidateId,
+                  type: "CALLS",
+                  line: call.loc ? call.loc.start.line : 0,
+                  confidence: 1
+                });
+                continue;
+              }
+              if (importedAs) {
+                const targetSymbolName = importedAs === "default" ? "default" : importedAs;
+                candidateId = `${targetFileId}::${targetSymbolName}.${call.method}`;
+                if (this.symbolIndex.has(candidateId)) {
+                  edges.push({
+                    sourceFileId: fileId,
+                    targetSymbolId: candidateId,
+                    type: "CALLS",
+                    line: call.loc ? call.loc.start.line : 0,
+                    confidence: 1
+                  });
+                  continue;
+                }
+              }
+            }
+            const localObjectId = `${fileId}::${call.object}.${call.method}`;
+            if (this.symbolIndex.has(localObjectId)) {
+              edges.push({
+                sourceFileId: fileId,
+                targetSymbolId: localObjectId,
+                type: "CALLS",
+                line: call.loc ? call.loc.start.line : 0,
+                confidence: 1
+              });
+            }
+          }
+        }
+        return edges;
+      }
+    };
+    module2.exports = { CallResolver };
+  }
+});
+
+// src/engine/pass2_semantics.js
+var require_pass2_semantics = __commonJS({
+  "src/engine/pass2_semantics.js"(exports2, module2) {
+    var path2 = require("path");
+    var { loadTSConfig } = require_tsconfig_utils();
+    var { resolveImport } = require_path_resolver();
+    var { SymbolIndexer } = require_symbol_indexer();
+    var { CallResolver } = require_call_resolver();
+    async function executePass2(rawNodes, rootDir, workspaceContext) {
+      console.log("\u{1F9E0} PASS 2: Semantic Resolution...");
+      const config = loadTSConfig(rootDir);
+      const tsconfig = config.options;
+      const configRoot = config.configDir;
+      const normalize = (p) => p.replace(/\\/g, "/");
+      const workspaceMap = workspaceContext ? workspaceContext.workspaceMap : null;
+      const fileSet = new Set(rawNodes.map((n) => n.id));
+      const edges = [];
+      const addEdge = (source, target, type, confidence = 1, metadata = {}) => {
+        if (!source || !target)
+          return;
+        if (source === target)
+          return;
+        edges.push({
+          source,
+          target,
+          type,
+          confidence,
+          metadata
+        });
+      };
+      let resolvedImports = 0;
+      for (const node of rawNodes) {
+        if (!node.facts.imports)
+          continue;
+        for (const imp of node.facts.imports) {
+          const importString = imp.source;
+          let targetId = null;
+          let resolvedPath = null;
+          const resolvedAbs = resolveImport(importString, node.filePath, configRoot, tsconfig, workspaceMap);
+          if (resolvedAbs) {
+            targetId = normalize(path2.relative(rootDir, resolvedAbs));
+            resolvedPath = targetId;
+            imp.resolvedPath = targetId;
+          } else {
+            if (importString.startsWith(".")) {
+              try {
+                const nodeDir = path2.dirname(node.filePath);
+                const simpleAbs = path2.resolve(nodeDir, importString);
+                const exts = [".ts", ".tsx", ".js", ".jsx", ".json", "/index.ts", "/index.js"];
+                for (const ext of [""].concat(exts)) {
+                  const candidate = normalize(path2.relative(rootDir, simpleAbs + ext));
+                  if (fileSet.has(candidate)) {
+                    targetId = candidate;
+                    imp.resolvedPath = candidate;
+                    break;
+                  }
+                }
+              } catch (e) {
+              }
+            }
+          }
+          if (targetId && fileSet.has(targetId)) {
+            let type = "imports";
+            if (workspaceContext && workspaceContext.workspaceMap) {
+            }
+            addEdge(node.id, targetId, type, 1, { specifiers: imp.specifiers });
+            resolvedImports++;
+          }
+        }
+      }
+      console.log(`   \u2713 Resolved ${resolvedImports} import dependencies`);
+      const symbolIndexer = new SymbolIndexer();
+      const nodesForIndexing = rawNodes.map((n) => ({
+        id: n.id,
+        metadata: n.facts
+        // Indexer expects metadata.exports, etc. (Pass 1 facts structure matches enough)
+      }));
+      const { symbols, fileToSymbols } = symbolIndexer.index(nodesForIndexing);
+      const callResolver = new CallResolver(symbols, null);
+      const nodesForResolution = rawNodes.map((n) => {
+        const combinedFunctions = [
+          ...n.facts.calls.functions || [],
+          ...(n.facts.react || []).map((r) => ({
+            name: r.component,
+            type: "jsx_component",
+            loc: r.loc
+          }))
+        ];
+        return {
+          id: n.id,
+          metadata: n.facts,
+          methodCalls: {
+            functionCalls: combinedFunctions,
+            methodCalls: n.facts.calls.methods,
+            constructorCalls: n.facts.calls.constructors
+          }
+        };
+      });
+      const callEdges = callResolver.resolve(nodesForResolution);
+      let resolvedCalls = 0;
+      for (const edge of callEdges) {
+        const symbol = symbols.get(edge.targetSymbolId);
+        if (symbol) {
+          const targetFileId = symbol.fileId;
+          if (fileSet.has(targetFileId)) {
+            addEdge(edge.sourceFileId, targetFileId, edge.type, edge.confidence, {
+              symbol: symbol.name,
+              symbolId: edge.targetSymbolId,
+              line: edge.line
+            });
+            resolvedCalls++;
+          }
+        }
+      }
+      console.log(`   \u2713 Resolved ${resolvedCalls} semantic call edges`);
+      let typeEdgesCount = 0;
+      for (const node of rawNodes) {
+        if (!node.facts.typeAnalysis)
+          continue;
+        const { typeImports, interfaceDeps, genericDeps } = node.facts.typeAnalysis;
+        for (const imp of typeImports) {
+          const resolvedAbs = resolveImport(imp.source, node.filePath, rootDir, tsconfig, workspaceMap);
+          if (resolvedAbs) {
+            const targetId = normalize(path2.relative(rootDir, resolvedAbs));
+            if (fileSet.has(targetId)) {
+              addEdge(node.id, targetId, "depends_on", 0.9, { type: "type_import" });
+              typeEdgesCount++;
+            }
+          }
+        }
+        const allTypeDeps = [...interfaceDeps, ...genericDeps];
+        for (const dep of allTypeDeps) {
+          const typeName = dep.extends || dep.implements || dep.returnType || dep.type;
+          if (!typeName)
+            continue;
+          for (const imp of node.facts.imports || []) {
+            if (imp.resolvedPath) {
+              const targetFileId = imp.resolvedPath;
+              const candidateId = `${targetFileId}::${typeName}`;
+              if (symbols.has(candidateId)) {
+                addEdge(node.id, targetFileId, "depends_on", 1, { type: "type_reference", symbol: typeName });
+                typeEdgesCount++;
+                break;
+              }
+            }
+          }
+        }
+      }
+      console.log(`   \u2713 Resolved ${typeEdgesCount} TypeScript type connections`);
+      return {
+        nodes: rawNodes,
+        edges,
+        symbols: Array.from(symbols.values())
+        // Return symbols list for ContextBuilder
+      };
+    }
+    module2.exports = { executePass2 };
+  }
+});
+
+// src/engine/pass3_lifter.js
+var require_pass3_lifter = __commonJS({
+  "src/engine/pass3_lifter.js"(exports2, module2) {
+    async function executePass3(semanticData) {
+      console.log("\u{1F9EC} PASS 3: Structural Lifting...");
+      const { nodes, edges } = semanticData;
+      const liftedNodes = [];
+      let rolesFound = {};
+      for (const node of nodes) {
+        let role = "module";
+        let layer = "generic";
+        const pathLower = node.id.toLowerCase();
+        const filename = node.id.split("/").pop();
+        if (pathLower.includes("service") || filename.endsWith(".service.ts")) {
+          role = "service";
+          layer = "logic";
+        } else if (pathLower.includes("controller") || filename.endsWith(".controller.ts")) {
+          role = "controller";
+          layer = "api";
+        } else if (pathLower.includes("component") || pathLower.includes(".tsx") || pathLower.includes(".jsx")) {
+          role = "component";
+          layer = "ui";
+        } else if (pathLower.includes("store") || pathLower.includes("redux") || pathLower.includes("context")) {
+          role = "store";
+          layer = "state";
+        } else if (pathLower.includes("util") || pathLower.includes("helper")) {
+          role = "utility";
+          layer = "shared";
+        } else if (pathLower.includes("model") || pathLower.includes("entity") || pathLower.includes("dto")) {
+          role = "model";
+          layer = "data";
+        } else if (pathLower.includes("config") || pathLower.includes("env")) {
+          role = "config";
+        } else if (pathLower.includes("hook") || filename.startsWith("use")) {
+          role = "hook";
+          layer = "ui-logic";
+        }
+        if (node.facts.di && (node.facts.di.injections.length > 0 || node.facts.di.context.length > 0)) {
+          if (role === "module")
+            role = "consumer";
+        }
+        if (node.facts.exports.some((e) => e.type === "class")) {
+          if (role === "module")
+            role = "class_def";
+        }
+        rolesFound[role] = (rolesFound[role] || 0) + 1;
+        liftedNodes.push({
+          ...node,
+          structure: {
+            role,
+            layer
+          }
+        });
+      }
+      console.log(`   \u2713 Inferred structural roles: ${JSON.stringify(rolesFound)}`);
+      return {
+        nodes: liftedNodes,
+        edges,
+        // Edges passed through
+        symbols: semanticData.symbols
+        // Propagate symbols
+      };
+    }
+    module2.exports = { executePass3 };
+  }
+});
+
 // src/core/blastRadius.js
 var require_blastRadius = __commonJS({
   "src/core/blastRadius.js"(exports2, module2) {
@@ -56896,7 +58368,12 @@ var require_blastRadius = __commonJS({
           // Consider files with blast radius > 5 as hubs
         });
       }
-      return criticalityAnalysis.sort((a, b) => b.criticalityScore - a.criticalityScore);
+      return criticalityAnalysis.sort((a, b) => {
+        if (b.criticalityScore !== a.criticalityScore) {
+          return b.criticalityScore - a.criticalityScore;
+        }
+        return a.file.localeCompare(b.file);
+      });
     }
     function calculateDependencyStrength(reverseGraph, file) {
       if (!reverseGraph[file] || !Array.isArray(reverseGraph[file])) {
@@ -56922,6 +58399,76 @@ var require_blastRadius = __commonJS({
   }
 });
 
+// src/engine/pass4_signals.js
+var require_pass4_signals = __commonJS({
+  "src/engine/pass4_signals.js"(exports2, module2) {
+    var { buildReverseDependencyGraph, computeBlastRadius, analyzeCriticality } = require_blastRadius();
+    async function executePass4(liftedData) {
+      console.log("\u{1F9E0} PASS 4: Signal Extraction & Metrics...");
+      const { nodes, edges } = liftedData;
+      const architectureMap = { nodes, edges };
+      const reverseGraph = buildReverseDependencyGraph(architectureMap);
+      const blastRadiusMap = computeBlastRadius(reverseGraph);
+      nodes.forEach((n) => {
+        n.metadata = n.facts;
+        n.metadata.blast_radius = blastRadiusMap[n.id] || 0;
+      });
+      const criticalityList = analyzeCriticality(blastRadiusMap, reverseGraph, nodes);
+      const criticalityMap = new Map(criticalityList.map((c) => [c.file, c]));
+      const finalNodes = nodes.map((node) => {
+        const signals = {
+          blast_radius: blastRadiusMap[node.id] || 0,
+          criticality: criticalityMap.get(node.id)?.criticalityScore || 0,
+          is_hub: criticalityMap.get(node.id)?.isHub || false,
+          // Calculate instability: closer to 1 means "depends on many things" (outgoing edges)
+          // (coupling)
+          outgoing_deps: edges.filter((e) => e.source === node.id).length,
+          incoming_deps: edges.filter((e) => e.target === node.id).length
+        };
+        return {
+          id: node.id,
+          type: node.type,
+          filePath: node.filePath,
+          // Internal absolute path
+          // The 3 Pillars of Arcvision
+          role: node.structure.role,
+          // From Pass 3
+          layer: node.structure.layer,
+          // From Pass 3
+          signals,
+          // From Pass 4
+          // Deep Code Intelligence (from Pass 1 & 2)
+          intelligence: {
+            ...node.facts,
+            // Add resolved outbound connections for easy traversal
+            connections: edges.filter((e) => e.source === node.id).map((e) => ({
+              target: e.target,
+              type: e.type,
+              confidence: e.confidence
+            }))
+          }
+        };
+      });
+      const totalFiles = finalNodes.length;
+      const maxBlast = Math.max(...finalNodes.map((n) => n.signals.blast_radius));
+      console.log(`   \u2713 Signals computed. Max Blast Radius: ${maxBlast}`);
+      const contextSurface = criticalityList.slice(0, 5).map((c) => ({
+        file: c.file,
+        score: c.criticalityScore,
+        reason: `Blast: ${c.blastRadius}, Deps: ${c.dependencies}`
+      }));
+      return {
+        nodes: finalNodes,
+        edges,
+        symbols: liftedData.symbols,
+        // Propagate symbols
+        contextSurface
+      };
+    }
+    module2.exports = { executePass4 };
+  }
+});
+
 // src/engine/id-generator.js
 var require_id_generator = __commonJS({
   "src/engine/id-generator.js"(exports2, module2) {
@@ -56934,81 +58481,109 @@ var require_id_generator = __commonJS({
   }
 });
 
-// src/engine/context_builder.js
+// src/core/context_builder.js
 var require_context_builder = __commonJS({
-  "src/engine/context_builder.js"(exports2, module2) {
+  "src/core/context_builder.js"(exports2, module2) {
     var path2 = require("path");
     var { stableId } = require_id_generator();
-    function buildContext(files, edges, options = {}) {
+    function buildContext(fileNodes, edges, symbols, options = {}) {
       const {
         directory = ".",
         projectName = "arcvision",
         language = "javascript"
       } = options;
-      const nodes = files.map((file) => {
-        const normalizedPath = file.id;
-        const hasFunctions = file.metadata.functions && file.metadata.functions.length > 0;
-        const hasClasses = file.metadata.classes && file.metadata.classes.length > 0;
-        const hasExports = file.metadata.exports && file.metadata.exports.length > 0;
-        const hasApiCalls = file.metadata.apiCalls && file.metadata.apiCalls.length > 0;
-        let role = "Structure";
-        if (hasFunctions || hasClasses || hasApiCalls) {
-          role = "Implementation";
-        } else if (hasExports) {
-          role = "Interface";
-        }
+      const nodes = fileNodes.map((file) => {
+        const role = file.role || "Structure";
+        const layer = file.layer || "generic";
         const dependencies = [];
         const uniqueDeps = /* @__PURE__ */ new Set();
-        if (file.metadata.imports && Array.isArray(file.metadata.imports)) {
-          file.metadata.imports.forEach((imp) => {
-            if (imp.source && typeof imp.source === "string") {
-              if (!uniqueDeps.has(imp.source)) {
-                uniqueDeps.add(imp.source);
-                dependencies.push(imp.source);
-              }
-            }
-          });
+        const addDep = (target) => {
+          if (target && !uniqueDeps.has(target)) {
+            uniqueDeps.add(target);
+            dependencies.push(target);
+          }
+        };
+        if (file.intelligence && file.intelligence.connections) {
+          file.intelligence.connections.forEach((c) => addDep(c.target));
+        } else {
+          edges.filter((e) => e.source === file.id).forEach((e) => addDep(e.target));
         }
-        return {
-          id: stableId(normalizedPath),
+        const nodeObj = {
+          id: stableId(file.id),
           type: "file",
-          path: normalizedPath,
+          path: file.id,
           role,
           dependencies,
-          blast_radius: file.metadata.blast_radius || 0
+          blast_radius: file.signals && file.signals.blast_radius || 0,
+          // New Schema Extensions (if supported by backend, otherwise ignored)
+          layer,
+          criticality: file.signals ? file.signals.criticality : 0
         };
+        return nodeObj;
       });
-      const schemaEdges = [];
+      const nodeMap = new Map(nodes.map((n) => [n.path, n]));
+      const edgeKeyMap = /* @__PURE__ */ new Map();
       for (const edge of edges) {
-        const sourceNode = nodes.find((n) => n.path === edge.source);
-        const targetNode = nodes.find((n) => n.path === edge.target);
-        if (sourceNode) {
+        const sourceNode = nodeMap.get(edge.source);
+        const targetNode = nodeMap.get(edge.target);
+        if (sourceNode && targetNode) {
           let relationType = "imports";
-          if (edge.type === "imports" || edge.type === "require" || edge.type === "export-from" || edge.type === "export-all" || edge.type === "dynamic-import" || edge.type === "require-assignment") {
-            relationType = "imports";
-          } else if (edge.type === "calls") {
-            relationType = "calls";
-          } else if (edge.type === "owns") {
-            relationType = "owns";
-          } else if (edge.type === "depends_on") {
-            relationType = "depends_on";
-          }
-          if (targetNode) {
-            schemaEdges.push({
+          switch (edge.type) {
+            case "function_call":
+            case "method_call":
+            case "constructor_call":
+            case "calls":
+            case "CALLS":
+            case "instantiates":
+            case "INSTANTIATES":
+            case "jsx_component":
+              relationType = "calls";
+              break;
+            case "injects":
+            case "depends_on":
+              relationType = "depends_on";
+              break;
+            case "owns":
+              relationType = "owns";
+              break;
+            case "imports":
+            case "require":
+            default:
+              relationType = "imports";
+              break;
+          }
+          const key = `${sourceNode.id}::${targetNode.id}::${relationType}`;
+          if (edgeKeyMap.has(key)) {
+            edgeKeyMap.get(key).weight = (edgeKeyMap.get(key).weight || 1) + 1;
+          } else {
+            edgeKeyMap.set(key, {
               from: sourceNode.id,
               to: targetNode.id,
-              relation: relationType
+              relation: relationType,
+              weight: 1
             });
-          } else {
           }
         }
       }
+      const schemaEdges = Array.from(edgeKeyMap.values()).sort((a, b) => {
+        if (a.from !== b.from)
+          return a.from.localeCompare(b.from);
+        if (a.to !== b.to)
+          return a.to.localeCompare(b.to);
+        return a.relation.localeCompare(b.relation);
+      });
       const metrics = {
         total_files: nodes.length,
         total_nodes: nodes.length,
         total_edges: schemaEdges.length,
-        total_imports: schemaEdges.length,
-        files_with_functions: nodes.filter((n) => n.role === "Implementation").length
+        total_imports: schemaEdges.filter((edge) => edge.relation === "imports").reduce((sum, e) => sum + (e.weight || 1), 0),
+        total_calls: schemaEdges.filter((edge) => edge.relation === "calls").reduce((sum, e) => sum + (e.weight || 1), 0),
+        total_owns: schemaEdges.filter((edge) => edge.relation === "owns").reduce((sum, e) => sum + (e.weight || 1), 0),
+        total_depends_on: schemaEdges.filter((edge) => edge.relation === "depends_on").reduce((sum, e) => sum + (e.weight || 1), 0),
+        files_with_functions: fileNodes.filter((n) => n.intelligence && n.intelligence.functions && n.intelligence.functions.length > 0).length,
+        // New metrics
+        total_dependencies: schemaEdges.length,
+        files_with_high_blast_radius: nodes.filter((n) => n.blast_radius > 5).length
       };
       const context = {
         schema_version: "1.0.0",
@@ -57020,12 +58595,10 @@ var require_context_builder = __commonJS({
         },
         nodes,
         edges: schemaEdges,
+        symbols: symbols || [],
         metrics,
-        contextSurface: options.contextSurface || {}
+        contextSurface: options.contextSurface || []
       };
-      context.metrics.files_with_functions = nodes.filter((n) => n.role === "Implementation").length;
-      context.metrics.files_with_high_blast_radius = nodes.filter((n) => n.blast_radius > 5).length;
-      context.metrics.total_dependencies = schemaEdges.length;
       return context;
     }
     module2.exports = { buildContext };
@@ -63583,374 +65156,53 @@ var require_context_sorter = __commonJS({
 // src/core/scanner.js
 var require_scanner = __commonJS({
   "src/core/scanner.js"(exports2, module2) {
-    var { glob } = require_commonjs5();
     var path2 = require("path");
-    var fs2 = require("fs");
-    var parser = require_parser();
-    var pluginManager = require_plugin_manager();
     var { loadTSConfig } = require_tsconfig_utils();
-    var { resolveImport } = require_path_resolver();
-    var { buildReverseDependencyGraph, computeBlastRadius } = require_blastRadius();
+    var { WorkspaceScanner } = require_workspace_scanner();
+    var { executePass1 } = require_pass1_facts();
+    var { executePass2 } = require_pass2_semantics();
+    var { executePass3 } = require_pass3_lifter();
+    var { executePass4 } = require_pass4_signals();
     var { buildContext } = require_context_builder();
     var { validateContext } = require_context_validator();
     var { sortContext } = require_context_sorter();
     async function scan(directory) {
-      const normalize = (p) => p.replace(/\\/g, "/");
-      const options = {
-        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"],
-        cwd: directory,
-        absolute: true
-      };
+      console.log(`
+\u{1F680} ARCVISION STRUCTURAL ENGINE (4-PASS)`);
+      console.log(`   Target: ${directory}
+`);
       try {
-        const pluginDir = path2.join(__dirname, "../plugins");
-        pluginManager.loadPluginsFromDirectory(pluginDir);
-        const files = await glob("**/*.{js,jsx,ts,tsx,json}", { ...options, ignore: [...options.ignore, "**/*.d.ts", "**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**"] });
-        const architectureMap = {
-          nodes: [],
-          edges: []
-        };
-        const fileMap = /* @__PURE__ */ new Map();
-        let totalImportsFound = 0;
-        for (const file of files) {
-          try {
-            const relativePath = path2.relative(directory, file);
-            const normalizedRelativePath = normalize(relativePath);
-            let metadata;
-            if (file.endsWith(".json")) {
-              try {
-                const content = fs2.readFileSync(file, "utf-8");
-                JSON.parse(content);
-                metadata = {
-                  id: file,
-                  imports: [],
-                  exports: [],
-                  functions: [],
-                  apiCalls: [],
-                  isJson: true
-                };
-              } catch (jsonError) {
-                console.warn(`\u26A0\uFE0F Invalid JSON in ${file} \u2014 file skipped`);
-                continue;
-              }
-            } else {
-              metadata = parser.parseFile(file);
-            }
-            metadata = await pluginManager.processFile(file, metadata);
-            if (metadata.imports && Array.isArray(metadata.imports)) {
-              totalImportsFound += metadata.imports.length;
-            }
-            const node = {
-              id: normalizedRelativePath,
-              type: "file",
-              metadata
-            };
-            architectureMap.nodes.push(node);
-            fileMap.set(normalizedRelativePath, metadata);
-          } catch (e) {
-            console.warn(`\u26A0\uFE0F Failed to process ${file} \u2014 file skipped, you should check manually (${e.message})`);
-          }
-        }
-        const tsconfig = loadTSConfig(directory);
-        const allPossiblePaths = /* @__PURE__ */ new Set();
-        const pathToNodeIdMap = /* @__PURE__ */ new Map();
-        architectureMap.nodes.forEach((node) => {
-          const normalizedPath = normalize(node.id);
-          allPossiblePaths.add(normalizedPath);
-          pathToNodeIdMap.set(normalizedPath, node.id);
-        });
-        let unresolvedImports = 0;
-        let resolvedImports = 0;
-        architectureMap.nodes.forEach((node) => {
-          if (node.metadata.imports && Array.isArray(node.metadata.imports)) {
-            node.metadata.imports.forEach((imp) => {
-              if (imp.source && typeof imp.source === "string") {
-                let targetFound = false;
-                try {
-                  if (allPossiblePaths.has(imp.source)) {
-                    architectureMap.edges.push({
-                      source: normalize(node.id),
-                      target: imp.source,
-                      type: imp.type || "import"
-                    });
-                    resolvedImports++;
-                    targetFound = true;
-                  }
-                  if (!targetFound) {
-                    const resolvedPath = resolveImport(
-                      imp.source,
-                      path2.join(directory, node.id),
-                      directory,
-                      tsconfig
-                    );
-                    if (resolvedPath) {
-                      const relativeResolvedPath = path2.relative(directory, resolvedPath);
-                      const normalizedResolvedPath = normalize(relativeResolvedPath);
-                      if (allPossiblePaths.has(normalizedResolvedPath)) {
-                        architectureMap.edges.push({
-                          source: normalize(node.id),
-                          target: normalizedResolvedPath,
-                          type: imp.type || "import"
-                        });
-                        resolvedImports++;
-                        targetFound = true;
-                      }
-                    }
-                  }
-                  if (!targetFound) {
-                    try {
-                      const baseDir = path2.dirname(path2.join(directory, node.id));
-                      const calculatedAbsolutePath = path2.resolve(baseDir, imp.source);
-                      const calculatedRelativePath = path2.relative(directory, calculatedAbsolutePath);
-                      const calculatedNormalizedPath = normalize(calculatedRelativePath);
-                      if (allPossiblePaths.has(calculatedNormalizedPath)) {
-                        architectureMap.edges.push({
-                          source: normalize(node.id),
-                          target: calculatedNormalizedPath,
-                          type: imp.type || "import"
-                        });
-                        resolvedImports++;
-                        targetFound = true;
-                      }
-                    } catch (e) {
-                      console.warn(`\u26A0\uFE0F Path calculation failed for import '${imp.source}' in file '${node.id}': ${e.message}`);
-                    }
-                  }
-                  if (!targetFound) {
-                    if (imp.source.startsWith("./") || imp.source.startsWith("../")) {
-                      const extensions = ["", ".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"];
-                      for (const ext of extensions) {
-                        let testPath = imp.source;
-                        if (!imp.source.endsWith(ext)) {
-                          testPath = imp.source + ext;
-                        }
-                        try {
-                          const baseDir = path2.dirname(path2.join(directory, node.id));
-                          const calculatedAbsolutePath = path2.resolve(baseDir, testPath);
-                          const calculatedRelativePath = path2.relative(directory, calculatedAbsolutePath);
-                          const calculatedNormalizedPath = normalize(calculatedRelativePath);
-                          if (allPossiblePaths.has(calculatedNormalizedPath)) {
-                            architectureMap.edges.push({
-                              source: normalize(node.id),
-                              target: calculatedNormalizedPath,
-                              type: imp.type || "import"
-                            });
-                            resolvedImports++;
-                            targetFound = true;
-                            break;
-                          }
-                        } catch (e) {
-                          console.warn(`\u26A0\uFE0F Extension path calculation failed for import '${imp.source}' with extension '${ext}' in file '${node.id}': ${e.message}`);
-                        }
-                      }
-                    }
-                  }
-                  if (!targetFound) {
-                    if (imp.source.startsWith("./") || imp.source.startsWith("../")) {
-                      try {
-                        const baseDir = path2.dirname(path2.join(directory, node.id));
-                        const calculatedAbsolutePath = path2.resolve(baseDir, imp.source);
-                        const directoryPath = calculatedAbsolutePath;
-                        const indexFiles = ["index.js", "index.ts", "index.jsx", "index.tsx", "index.mjs", "index.cjs"];
-                        for (const indexFile of indexFiles) {
-                          const indexPath = path2.join(directoryPath, indexFile);
-                          const indexRelativePath = path2.relative(directory, indexPath);
-                          const indexNormalizedPath = normalize(indexRelativePath);
-                          if (allPossiblePaths.has(indexNormalizedPath)) {
-                            architectureMap.edges.push({
-                              source: normalize(node.id),
-                              target: indexNormalizedPath,
-                              type: imp.type || "import"
-                            });
-                            resolvedImports++;
-                            targetFound = true;
-                            break;
-                          }
-                        }
-                      } catch (e) {
-                        console.warn(`\u26A0\uFE0F Index file check failed for import '${imp.source}' in file '${node.id}': ${e.message}`);
-                      }
-                    }
-                  }
-                  if (!targetFound) {
-                    if (imp.source.startsWith("@") || imp.source.startsWith("/") || !imp.source.startsWith(".")) {
-                      const commonSourceDirs = ["src", "app", "lib", "components", "utils", "services", "assets"];
-                      for (const srcDir of commonSourceDirs) {
-                        const potentialPath = path2.join(srcDir, imp.source);
-                        const potentialRelativePath = path2.relative(directory, path2.resolve(directory, potentialPath));
-                        const potentialNormalizedPath = normalize(potentialRelativePath);
-                        if (allPossiblePaths.has(potentialNormalizedPath)) {
-                          architectureMap.edges.push({
-                            source: normalize(node.id),
-                            target: potentialNormalizedPath,
-                            type: imp.type || "import"
-                          });
-                          resolvedImports++;
-                          targetFound = true;
-                          break;
-                        }
-                        const extensions = [
-                          ".js",
-                          ".ts",
-                          ".jsx",
-                          ".tsx",
-                          ".mjs",
-                          ".cjs",
-                          "index.js",
-                          "index.ts",
-                          "index.jsx",
-                          "index.tsx",
-                          "index.mjs",
-                          "index.cjs"
-                        ];
-                        for (const ext of extensions) {
-                          let testPath;
-                          if (ext.startsWith("index")) {
-                            testPath = path2.join(srcDir, imp.source, ext);
-                          } else {
-                            testPath = path2.join(srcDir, imp.source + ext);
-                          }
-                          const testRelativePath = path2.relative(directory, path2.resolve(directory, testPath));
-                          const testNormalizedPath = normalize(testRelativePath);
-                          if (allPossiblePaths.has(testNormalizedPath)) {
-                            architectureMap.edges.push({
-                              source: normalize(node.id),
-                              target: testNormalizedPath,
-                              type: imp.type || "import"
-                            });
-                            resolvedImports++;
-                            targetFound = true;
-                            break;
-                          }
-                        }
-                        if (targetFound)
-                          break;
-                      }
-                    }
-                  }
-                  if (!targetFound) {
-                    if (imp.source.startsWith("@") || imp.source.startsWith("/")) {
-                      try {
-                        const parts = imp.source.split("/");
-                        if (parts.length > 1) {
-                          const dirParts = parts.slice(0, -1);
-                          const fileName = parts[parts.length - 1];
-                          const dirPath = dirParts.join("/") + "/index";
-                          const indexFiles = ["index.js", "index.ts", "index.jsx", "index.tsx", "index.mjs", "index.cjs"];
-                          for (const indexFile of indexFiles) {
-                            const indexPath = path2.join(dirParts.join("/"), indexFile);
-                            const indexRelativePath = path2.relative(directory, path2.resolve(directory, indexPath));
-                            const indexNormalizedPath = normalize(indexRelativePath);
-                            if (allPossiblePaths.has(indexNormalizedPath)) {
-                              architectureMap.edges.push({
-                                source: normalize(node.id),
-                                target: indexNormalizedPath,
-                                type: imp.type || "import"
-                              });
-                              resolvedImports++;
-                              targetFound = true;
-                              break;
-                            }
-                          }
-                        }
-                      } catch (e) {
-                        console.warn(`\u26A0\uFE0F Barrel file check failed for import '${imp.source}' in file '${node.id}': ${e.message}`);
-                      }
-                    }
-                  }
-                  if (!targetFound) {
-                    for (const possiblePath of allPossiblePaths) {
-                      if (possiblePath.toLowerCase() === imp.source.toLowerCase()) {
-                        architectureMap.edges.push({
-                          source: normalize(node.id),
-                          target: possiblePath,
-                          type: imp.type || "import"
-                        });
-                        resolvedImports++;
-                        targetFound = true;
-                        break;
-                      }
-                    }
-                  }
-                } catch (e) {
-                  console.error(`\u274C Critical error processing import '${imp.source}' in file '${node.id}': ${e.message}`);
-                  console.error(e.stack);
-                  unresolvedImports++;
-                }
-                if (!targetFound) {
-                  unresolvedImports++;
-                }
-              }
-            });
-          }
-        });
-        console.log("RESOLVED IMPORTS:", resolvedImports);
-        console.log("UNRESOLVED IMPORTS:", unresolvedImports);
-        console.log("EDGES CREATED:", architectureMap.edges.length);
-        const reverseGraph = buildReverseDependencyGraph(architectureMap);
-        const blastRadiusMap = computeBlastRadius(reverseGraph);
-        architectureMap.nodes.forEach((node) => {
-          node.metadata.blast_radius = blastRadiusMap[node.id] || 0;
-        });
-        console.log("BEFORE DEDUPLICATION EDGES:", architectureMap.edges.length);
-        const validEdges = [];
-        const edgeSet = /* @__PURE__ */ new Set();
-        architectureMap.edges.forEach((edge) => {
-          const normalizedSource = normalize(edge.source);
-          const normalizedTarget = normalize(edge.target);
-          const edgeKey = `${normalizedSource}\u2192${normalizedTarget}`;
-          const sourceNodeExists = architectureMap.nodes.some((node) => node.id === normalizedSource);
-          const targetNodeExists = architectureMap.nodes.some((node) => node.id === normalizedTarget);
-          if (sourceNodeExists && targetNodeExists && !edgeSet.has(edgeKey)) {
-            edgeSet.add(edgeKey);
-            validEdges.push({
-              source: normalizedSource,
-              target: normalizedTarget,
-              type: edge.type
-            });
-          }
-        });
-        console.log("AFTER DEDUPLICATION EDGES:", validEdges.length);
-        architectureMap.edges = validEdges;
-        const totalFiles = architectureMap.nodes.length;
-        const { computeBlastRadiusWithPercentage: computeBlastRadiusWithPercentage2, analyzeCriticality } = require_blastRadius();
-        const allFilesWithPercentage = computeBlastRadiusWithPercentage2(blastRadiusMap, totalFiles);
-        const criticalityAnalysis = analyzeCriticality(blastRadiusMap, reverseGraph, architectureMap.nodes);
-        const topFiles = allFilesWithPercentage.slice(0, 3);
-        architectureMap.contextSurface = {
-          topBlastRadiusFiles: topFiles,
-          criticalityAnalysis: criticalityAnalysis.slice(0, 5)
-          // Top 5 most critical files
-        };
-        let context = buildContext(architectureMap.nodes, architectureMap.edges, {
+        const start = Date.now();
+        const workspaceScanner = new WorkspaceScanner(directory);
+        const workspaceContext = workspaceScanner.scan();
+        const rawNodes = await executePass1(directory);
+        const semanticData = await executePass2(rawNodes, directory, workspaceContext);
+        const liftedData = await executePass3(semanticData);
+        const structuralContext = await executePass4(liftedData);
+        const { nodes, edges, contextSurface, symbols } = structuralContext;
+        console.log(`
+\u{1F50D} Analysis Complete (${Date.now() - start}ms)`);
+        console.log(`   Nodes: ${nodes.length}`);
+        console.log(`   Edges: ${edges.length}`);
+        console.log(`   Symbols: ${symbols ? symbols.length : 0}`);
+        const contextOptions = {
           directory,
           projectName: path2.basename(directory),
-          language: "javascript",
-          contextSurface: architectureMap.contextSurface
-        });
-        console.log("Validating structural context...");
+          contextSurface
+        };
+        let context = buildContext(nodes, edges, symbols, contextOptions);
+        console.log("   Validating structural context...");
         let validation = validateContext(context);
         if (!validation.valid) {
-          console.error("VALIDATION FAILED (Attempt 1)");
-          validation.errors.forEach((e) => console.error(" -", e));
-          console.log("Re-running generation deterministically...");
-          context = buildContext(architectureMap.nodes, architectureMap.edges, {
-            directory,
-            projectName: path2.basename(directory),
-            language: "javascript",
-            contextSurface: architectureMap.contextSurface
-          });
-          validation = validateContext(context);
-          if (!validation.valid) {
-            console.error("VALIDATION FAILED (Attempt 2)");
-            validation.errors.forEach((e) => console.error(" -", e));
-            console.error("ABORTING. JSON NOT SAVED.");
-            process.exit(1);
-          }
+          console.error("   \u274C Validation Failed");
+          validation.errors.forEach((e) => console.error("    -", e));
+          throw new Error("Context validation failed");
         }
         const sortedContext = sortContext(context);
-        console.log("STRUCTURAL CONTEXT VALIDATED \u2014 READY FOR UPLOAD");
+        console.log("   \u2705 Context Verified & Ready");
         return sortedContext;
       } catch (err) {
+        console.error("\u274C Scanner Failed:", err);
         throw err;
       }
     }
@@ -64180,7 +65432,6 @@ program.command("scan").description("Scan the current directory and generate arc
       const outputFileName = "arcvision.context.json";
       fs2.writeFileSync(outputFileName, JSON.stringify(map, null, 2));
       console.log(chalk.green(`\u2705 Structural context saved to ${outputFileName}`));
-      console.log(JSON.stringify(map, null, 2));
       console.log(chalk.dim("\nUse --upload to send to dashboard."));
     }
   } catch (error) {