circle-ir 3.31.0 → 3.33.0

package/dist/browser/circle-ir.js

@@ -9605,6 +9605,448 @@ function findChildByTypeGo(node, type) {
   return null;
 }
 
+// src/core/extractors/runtime-registrations.ts
+var HTTP_VERB_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options",
+  "all"
+]);
+var MIDDLEWARE_METHODS = /* @__PURE__ */ new Set(["use"]);
+var EVENT_LISTENER_METHODS = /* @__PURE__ */ new Set(["on", "once", "ws"]);
+var EXPRESS_RECEIVER_NAMES = /* @__PURE__ */ new Set([
+  "app",
+  "router",
+  "server",
+  "apiRouter",
+  // common framework instances
+  "fastify",
+  "koa",
+  "express"
+]);
+var FRAMEWORK_MODULE_PATTERNS = [
+  /^express$/,
+  /^@?fastify(\/.*)?$/,
+  /^koa$/,
+  /^restify$/,
+  /^hapi$/,
+  /^@nestjs\/common$/,
+  /^@nestjs\/core$/
+];
+function extractRuntimeRegistrations(tree, cache, language, imports) {
+  if (language === "javascript" || language === "typescript") {
+    return extractJSRuntimeRegistrations(tree, cache, imports);
+  }
+  if (language === "python") {
+    return extractPythonRuntimeRegistrations(tree, cache, imports);
+  }
+  return [];
+}
+function buildHandlerIndex(tree, cache, imports) {
+  const decls = /* @__PURE__ */ new Map();
+  const recordDeclaration = (name2, node) => {
+    if (!decls.has(name2)) {
+      decls.set(name2, {
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column
+      });
+    }
+  };
+  for (const fn of getNodesFromCache(tree.rootNode, "function_declaration", cache)) {
+    const nameNode = fn.childForFieldName("name");
+    if (nameNode) recordDeclaration(getNodeText(nameNode), fn);
+  }
+  const collectVarDeclarators = (parentType) => {
+    for (const decl of getNodesFromCache(tree.rootNode, parentType, cache)) {
+      for (let i2 = 0; i2 < decl.childCount; i2++) {
+        const child = decl.child(i2);
+        if (!child || child.type !== "variable_declarator") continue;
+        const nameNode = child.childForFieldName("name");
+        const valueNode = child.childForFieldName("value");
+        if (!nameNode || !valueNode) continue;
+        if (valueNode.type === "arrow_function" || valueNode.type === "function_expression" || valueNode.type === "function") {
+          recordDeclaration(getNodeText(nameNode), child);
+        }
+      }
+    }
+  };
+  collectVarDeclarators("lexical_declaration");
+  collectVarDeclarators("variable_declaration");
+  let hasFrameworkImport = false;
+  if (imports) {
+    for (const imp of imports) {
+      const mod = imp.from_package ?? "";
+      if (mod && FRAMEWORK_MODULE_PATTERNS.some((re) => re.test(mod))) {
+        hasFrameworkImport = true;
+        break;
+      }
+    }
+  }
+  return { declarations: decls, hasFrameworkImport };
+}
+function extractJSRuntimeRegistrations(tree, cache, imports) {
+  const out2 = [];
+  const index = buildHandlerIndex(tree, cache, imports);
+  const callExpressions = getNodesFromCache(tree.rootNode, "call_expression", cache);
+  for (const call of callExpressions) {
+    const fnNode = call.childForFieldName("function");
+    if (!fnNode || fnNode.type !== "member_expression") continue;
+    const objectNode = fnNode.childForFieldName("object");
+    const propertyNode = fnNode.childForFieldName("property");
+    if (!objectNode || !propertyNode) continue;
+    const method = getNodeText(propertyNode);
+    const receiver = getNodeText(objectNode);
+    const kind = classifyMethod(method);
+    if (!kind) continue;
+    if (!isExpressShapedReceiver(receiver) && !index.hasFrameworkImport) {
+      continue;
+    }
+    const argsNode = call.childForFieldName("arguments");
+    if (!argsNode) continue;
+    const argNodes = getRealArgs(argsNode);
+    if (argNodes.length === 0) continue;
+    let path;
+    let handlerStart = 0;
+    const first = argNodes[0];
+    if (first.type === "string") {
+      path = stripQuotes(getNodeText(first));
+      handlerStart = 1;
+    } else if (first.type === "template_string" && !hasTemplateSubstitution(first)) {
+      path = stripBackticks(getNodeText(first));
+      handlerStart = 1;
+    }
+    for (let i2 = handlerStart; i2 < argNodes.length; i2++) {
+      const handlerNode = argNodes[i2];
+      const handler = resolveHandler(handlerNode, index);
+      if (!handler) continue;
+      out2.push({
+        kind,
+        framework: inferFramework(receiver, index.hasFrameworkImport),
+        registrar: {
+          method,
+          receiver,
+          line: call.startPosition.row + 1,
+          column: call.startPosition.column
+        },
+        ...path !== void 0 ? { path } : {},
+        handler
+      });
+    }
+  }
+  return out2;
+}
+function classifyMethod(method) {
+  if (HTTP_VERB_METHODS.has(method)) return "http_route";
+  if (MIDDLEWARE_METHODS.has(method)) return "middleware";
+  if (EVENT_LISTENER_METHODS.has(method)) return "event_listener";
+  return null;
+}
+function isExpressShapedReceiver(receiver) {
+  if (EXPRESS_RECEIVER_NAMES.has(receiver)) return true;
+  if (/(?:Router|App|Server)$/.test(receiver)) return true;
+  return false;
+}
+function inferFramework(receiver, hasFrameworkImport) {
+  if (receiver === "fastify") return "fastify";
+  if (receiver === "koa") return "koa";
+  if (receiver === "express") return "express";
+  return hasFrameworkImport ? "express" : "unknown";
+}
+function getRealArgs(argsNode) {
+  const out2 = [];
+  for (let i2 = 0; i2 < argsNode.childCount; i2++) {
+    const child = argsNode.child(i2);
+    if (!child) continue;
+    if (child.type === "(" || child.type === ")" || child.type === ",") continue;
+    out2.push(child);
+  }
+  return out2;
+}
+function stripQuotes(s) {
+  if (s.length >= 2 && (s[0] === '"' || s[0] === "'") && s[s.length - 1] === s[0]) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function stripBackticks(s) {
+  if (s.length >= 2 && s[0] === "`" && s[s.length - 1] === "`") {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function hasTemplateSubstitution(node) {
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const child = node.child(i2);
+    if (child && child.type === "template_substitution") return true;
+  }
+  return false;
+}
+function resolveHandler(node, index) {
+  if (node.type === "arrow_function" || node.type === "function_expression" || node.type === "function") {
+    return {
+      name: null,
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column
+    };
+  }
+  if (node.type === "identifier") {
+    const name2 = getNodeText(node);
+    const decl = index.declarations.get(name2);
+    if (decl) {
+      return { name: name2, line: decl.line, column: decl.column };
+    }
+    return {
+      name: name2,
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column
+    };
+  }
+  if (node.type === "member_expression") {
+    return {
+      name: getNodeText(node),
+      line: node.startPosition.row + 1,
+      column: node.startPosition.column
+    };
+  }
+  return null;
+}
+var PY_HTTP_ROUTE_METHODS = /* @__PURE__ */ new Set([
+  // Flask/Blueprint: app.route, blueprint.route, api.route
+  "route",
+  // FastAPI / Starlette / DRF method-specific
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head",
+  "options"
+  // Flask aliases (Flask 2.x): app.get/post/...
+]);
+var PY_MIDDLEWARE_METHODS = /* @__PURE__ */ new Set([
+  "before_request",
+  "after_request",
+  "teardown_request",
+  "before_first_request",
+  "teardown_appcontext",
+  // Starlette / FastAPI
+  "middleware"
+]);
+var PY_EVENT_METHODS = /* @__PURE__ */ new Set([
+  "errorhandler",
+  "on_event",
+  "exception_handler"
+  // Celery beat etc — not strictly events but lifecycle
+]);
+var PY_STDLIB_DECORATORS = /* @__PURE__ */ new Set([
+  "property",
+  "staticmethod",
+  "classmethod",
+  "abstractmethod",
+  "cached_property",
+  "dataclass",
+  "cache",
+  "lru_cache",
+  "singledispatch",
+  "singledispatchmethod",
+  "contextmanager",
+  "asynccontextmanager",
+  "final",
+  "override",
+  "wraps"
+]);
+function summarisePythonImports(imports) {
+  const s = {
+    hasFlask: false,
+    hasFastApi: false,
+    hasCelery: false,
+    hasNumba: false,
+    hasClick: false,
+    hasPytest: false
+  };
+  if (!imports) return s;
+  for (const imp of imports) {
+    const mod = imp.from_package ?? "";
+    if (!mod) continue;
+    if (/^flask(\b|\.)/.test(mod)) s.hasFlask = true;
+    if (/^fastapi(\b|\.)/.test(mod) || /^starlette(\b|\.)/.test(mod)) s.hasFastApi = true;
+    if (/^celery(\b|\.)/.test(mod)) s.hasCelery = true;
+    if (/^numba(\b|\.)/.test(mod)) s.hasNumba = true;
+    if (/^click(\b|\.)/.test(mod)) s.hasClick = true;
+    if (/^pytest(\b|\.)/.test(mod)) s.hasPytest = true;
+  }
+  return s;
+}
+function extractPythonRuntimeRegistrations(tree, cache, imports) {
+  const out2 = [];
+  const importSummary = summarisePythonImports(imports);
+  const decoratedDefs = getNodesFromCache(tree.rootNode, "decorated_definition", cache);
+  for (const dd of decoratedDefs) {
+    let fnNode = null;
+    const decorators = [];
+    for (let i2 = 0; i2 < dd.childCount; i2++) {
+      const child = dd.child(i2);
+      if (!child) continue;
+      if (child.type === "decorator") {
+        decorators.push(child);
+      } else if (child.type === "function_definition" || child.type === "async_function_definition") {
+        fnNode = child;
+      }
+    }
+    if (!fnNode || decorators.length === 0) continue;
+    const handler = pythonHandlerFromFunctionDef(fnNode);
+    if (!handler) continue;
+    for (const dec of decorators) {
+      const parsed = parsePythonDecorator(dec);
+      if (!parsed) continue;
+      const { receiver, method, path, line, column } = parsed;
+      const { kind, framework } = classifyPythonDecorator(
+        receiver,
+        method,
+        importSummary
+      );
+      out2.push({
+        kind,
+        framework,
+        registrar: { method, receiver, line, column },
+        ...path !== void 0 ? { path } : {},
+        handler
+      });
+    }
+  }
+  return out2;
+}
+function pythonHandlerFromFunctionDef(fn) {
+  const nameNode = fn.childForFieldName("name");
+  if (!nameNode) return null;
+  return {
+    name: getNodeText(nameNode),
+    line: fn.startPosition.row + 1,
+    column: fn.startPosition.column
+  };
+}
+function parsePythonDecorator(dec) {
+  let target = null;
+  for (let i2 = 0; i2 < dec.childCount; i2++) {
+    const child = dec.child(i2);
+    if (!child || child.type === "@") continue;
+    target = child;
+    break;
+  }
+  if (!target) return null;
+  const line = dec.startPosition.row + 1;
+  const column = dec.startPosition.column;
+  if (target.type === "identifier") {
+    return { receiver: "", method: getNodeText(target), line, column };
+  }
+  if (target.type === "attribute") {
+    const { receiver, method } = splitDottedAttribute(target);
+    return { receiver, method, line, column };
+  }
+  if (target.type === "call") {
+    const fnNode = target.childForFieldName("function");
+    if (!fnNode) return null;
+    let receiver = "";
+    let method = "";
+    if (fnNode.type === "identifier") {
+      method = getNodeText(fnNode);
+    } else if (fnNode.type === "attribute") {
+      const split = splitDottedAttribute(fnNode);
+      receiver = split.receiver;
+      method = split.method;
+    } else {
+      method = getNodeText(fnNode);
+    }
+    const path = extractFirstStringArg(target);
+    return { receiver, method, path, line, column };
+  }
+  return null;
+}
+function splitDottedAttribute(attr) {
+  const objectNode = attr.childForFieldName("object");
+  const attrNode = attr.childForFieldName("attribute");
+  const method = attrNode ? getNodeText(attrNode) : "";
+  const receiver = objectNode ? getNodeText(objectNode) : "";
+  return { receiver, method };
+}
+function extractFirstStringArg(call) {
+  const argsNode = call.childForFieldName("arguments");
+  if (!argsNode) return void 0;
+  for (let i2 = 0; i2 < argsNode.childCount; i2++) {
+    const child = argsNode.child(i2);
+    if (!child) continue;
+    if (child.type === "(" || child.type === ")" || child.type === ",") continue;
+    if (child.type === "string") {
+      return stripPythonStringQuotes(getNodeText(child));
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function stripPythonStringQuotes(s) {
+  const m = s.match(/^[bBrRuUfF]{0,2}(['"])(.*)\1$/s);
+  if (m) return m[2];
+  if (s.length >= 2 && (s[0] === '"' || s[0] === "'") && s[s.length - 1] === s[0]) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function classifyPythonDecorator(receiver, method, imp) {
+  if (!receiver && PY_STDLIB_DECORATORS.has(method)) {
+    return { kind: "decorator", framework: "stdlib" };
+  }
+  if (receiver) {
+    const head = receiver.split(".")[0];
+    if (head === "pytest") {
+      return { kind: "decorator", framework: "pytest" };
+    }
+    if (head === "click") {
+      return { kind: "decorator", framework: "click" };
+    }
+    if (head === "numba" || head === "nb") {
+      return { kind: "decorator", framework: "numba" };
+    }
+    if (head === "celery") {
+      return { kind: "decorator", framework: "celery" };
+    }
+  }
+  if (receiver && PY_HTTP_ROUTE_METHODS.has(method)) {
+    const isRoutey = isPyRouterReceiver(receiver);
+    if (isRoutey) {
+      let framework = "unknown";
+      if (imp.hasFlask) framework = "flask";
+      else if (imp.hasFastApi) framework = "fastapi";
+      else if (method === "route") framework = "flask";
+      else framework = "fastapi";
+      return { kind: "http_route", framework };
+    }
+  }
+  if (receiver && PY_MIDDLEWARE_METHODS.has(method)) {
+    return { kind: "middleware", framework: imp.hasFlask ? "flask" : imp.hasFastApi ? "fastapi" : "unknown" };
+  }
+  if (receiver && PY_EVENT_METHODS.has(method)) {
+    return { kind: "event_listener", framework: imp.hasFlask ? "flask" : imp.hasFastApi ? "fastapi" : "unknown" };
+  }
+  if (method === "task" && imp.hasCelery) {
+    return { kind: "decorator", framework: "celery" };
+  }
+  if (!receiver && (method === "login_required" || method === "require_http_methods" || method === "api_view")) {
+    return { kind: "decorator", framework: "django" };
+  }
+  return { kind: "decorator", framework: "unknown" };
+}
+function isPyRouterReceiver(receiver) {
+  const head = receiver.split(".")[0];
+  if (!head) return false;
+  if (["app", "router", "blueprint", "bp", "api", "application"].includes(head)) return true;
+  if (/_(router|bp|blueprint|app|api)$/.test(head)) return true;
+  return false;
+}
+
 // src/analysis/config-loader.ts
 var DEFAULT_SOURCES = [
   // HTTP Sources (Servlet API)
@@ -19778,7 +20220,7 @@ function extractEventHandlers(elementNode, eventHandlers) {
     if (!EVENT_HANDLER_ATTRS.has(attrName)) continue;
     const valueNode = findChildByType2(child, "quoted_attribute_value") ?? findChildByType2(child, "attribute_value");
     if (!valueNode) continue;
-    const code = stripQuotes(valueNode.text);
+    const code = stripQuotes2(valueNode.text);
     if (code) {
       eventHandlers.push({
         code,
@@ -19809,7 +20251,7 @@ function getAttributeValue(tag, name2) {
     const nameNode = findChildByType2(child, "attribute_name");
     if (nameNode?.text.toLowerCase() === name2) {
       const valueNode = findChildByType2(child, "quoted_attribute_value") ?? findChildByType2(child, "attribute_value");
-      return valueNode ? stripQuotes(valueNode.text) : "";
+      return valueNode ? stripQuotes2(valueNode.text) : "";
     }
   }
   return void 0;
@@ -19821,7 +20263,7 @@ function findChildByType2(node, type) {
   }
   return null;
 }
-function stripQuotes(text) {
+function stripQuotes2(text) {
   if (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'")) {
     return text.slice(1, -1);
   }
@@ -25024,7 +25466,7 @@ var SecurityHeadersPass = class {
 };
 function literalOf(arg) {
   if (arg.literal !== null && arg.literal !== void 0 && arg.literal !== "") {
-    return stripQuotes2(arg.literal);
+    return stripQuotes3(arg.literal);
   }
   const expr = arg.expression.trim();
   if (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'") || expr.startsWith("`") && expr.endsWith("`")) {
@@ -25033,7 +25475,7 @@ function literalOf(arg) {
   }
   return null;
 }
-function stripQuotes2(s) {
+function stripQuotes3(s) {
   if (s.length < 2) return s;
   const first = s[0];
   const last = s[s.length - 1];
@@ -26120,7 +26562,9 @@ function getNodeTypesForLanguage(language) {
         "import_from_statement",
         "assignment",
         "attribute",
-        "subscript"
+        "subscript",
+        "decorated_definition",
+        "decorator"
       ]);
     case "javascript":
     case "typescript":
@@ -26212,6 +26656,7 @@ async function analyze(code, filePath, language, options = {}) {
     const exports = extractExports(types);
     const cfg = buildCFG(tree, language);
     const dfg = buildDFG(tree, nodeCache, language);
+    const runtimeRegistrations = extractRuntimeRegistrations(tree, nodeCache, language, imports);
     const graph = new CodeGraph({
       meta,
       types,
@@ -26306,7 +26751,8 @@ async function analyze(code, filePath, language, options = {}) {
       unresolved,
       enriched,
       findings: findings.length > 0 ? findings : void 0,
-      metrics: { file: filePath, metrics: metricValues }
+      metrics: { file: filePath, metrics: metricValues },
+      runtime_registrations: runtimeRegistrations.length > 0 ? runtimeRegistrations : void 0
     };
   } finally {
     disposeTree(tree);

package/dist/core/extractors/index.d.ts

@@ -8,4 +8,5 @@ export { extractImports } from './imports.js';
 export { extractExports } from './exports.js';
 export { buildCFG } from './cfg.js';
 export { buildDFG } from './dfg.js';
+export { extractRuntimeRegistrations } from './runtime-registrations.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/extractors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/core/extractors/index.js

@@ -8,4 +8,5 @@ export { extractImports } from './imports.js';
 export { extractExports } from './exports.js';
 export { buildCFG } from './cfg.js';
 export { buildDFG } from './dfg.js';
+export { extractRuntimeRegistrations } from './runtime-registrations.js';
 //# sourceMappingURL=index.js.map

package/dist/core/extractors/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/extractors/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/extractors/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/core/extractors/runtime-registrations.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Runtime-registration extractor (issue #15 — Phases 1 + 2).
+ *
+ * Recognises framework registration patterns where a handler is wired into a
+ * dispatch table at module-load time. Static call extraction sees the
+ * registration call/decorator but not the edge from registrar → handler.
+ *
+ * Downstream consumers (e.g. dead-code reachability) read
+ * `ir.runtime_registrations` and add each resolved handler as a virtual entry
+ * root, eliminating "unreachable" false positives for framework handlers.
+ *
+ * Phase 1 — JS/TS Express-family (shipped 3.32.0):
+ *   - HTTP routes: `app.METHOD(path?, ...handlers)` for METHOD ∈ HTTP_VERBS
+ *   - Middleware: `app.use(...handlers)`
+ *   - Event listeners: `emitter.on('event', handler)` on express-shaped receivers
+ *
+ * Phase 2 — Python decorators (3.33.0):
+ *   - Every `@decorator` on a function emits a registration with handler =
+ *     decorated function. Known frameworks are tagged (flask, fastapi,
+ *     django, click, pytest, celery, numba); built-in (property,
+ *     staticmethod, etc.) is tagged `stdlib`. Routing-style decorators
+ *     (`@app.route`, `@app.get`, `@router.post`) are classified as
+ *     `kind: 'http_route'` so downstream consumers can treat JS routes and
+ *     Python routes uniformly.
+ *
+ * Out of scope (Phase 3):
+ *   - Rust trait dispatch (`impl Trait for Type`, `Box<dyn Trait>`,
+ *     `inventory::submit!`, `linkme::distributed_slice`).
+ *   - Subapp mounting (`app.use('/api', subApp)`) handler resolution.
+ */
+import type { Tree } from 'web-tree-sitter';
+import type { RuntimeRegistration, ImportInfo } from '../../types/index.js';
+import { type NodeCache } from '../parser.js';
+import type { SupportedLanguage } from '../parser.js';
+/**
+ * Extract runtime-registration patterns from a parsed file.
+ *
+ * Phase 1 covers JavaScript/TypeScript. Phase 2 adds Python decorators.
+ * Returns `[]` for any other language.
+ */
+export declare function extractRuntimeRegistrations(tree: Tree, cache: NodeCache | undefined, language: SupportedLanguage | string, imports?: ImportInfo[]): RuntimeRegistration[];
+//# sourceMappingURL=runtime-registrations.d.ts.map

package/dist/core/extractors/runtime-registrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-registrations.d.ts","sourceRoot":"","sources":["../../../src/core/extractors/runtime-registrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAkC,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AA2BtD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,QAAQ,EAAE,iBAAiB,GAAG,MAAM,EACpC,OAAO,CAAC,EAAE,UAAU,EAAE,GACrB,mBAAmB,EAAE,CAQvB"}