@launchsecure/launch-kit 0.0.33 → 0.0.35

package/dist/server/chart-serve.js

@@ -246,6 +246,7 @@ function emptyParsedFile(absPath) {
   return {
     name: absPath.split("/").pop() ?? absPath,
     exports: [],
+    defines: [],
     imports: [],
     reExports: [],
     jsxElements: /* @__PURE__ */ new Set(),
@@ -358,6 +359,34 @@ function parseFileTS(absPath) {
       reExports.push({ name: "*", from: caps["reexport.wildcard.source"], isWildcard: true });
     }
   }
+  const definesSet = /* @__PURE__ */ new Set();
+  function recordCallable(decl) {
+    if (decl.type === "function_declaration" || decl.type === "generator_function_declaration") {
+      const id = childOfType(decl, "identifier");
+      if (id) definesSet.add(id.text);
+      return;
+    }
+    if (decl.type === "class_declaration") {
+      const id = childOfType(decl, "type_identifier") ?? childOfType(decl, "identifier");
+      if (id) definesSet.add(id.text);
+      return;
+    }
+    if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
+      for (const d of childrenOfType(decl, "variable_declarator")) {
+        const id = childOfType(d, "identifier");
+        if (!id) continue;
+        const isCallable = !!childOfType(d, "arrow_function") || !!childOfType(d, "function_expression") || !!childOfType(d, "function") || !!childOfType(d, "generator_function");
+        if (isCallable) definesSet.add(id.text);
+      }
+    }
+  }
+  for (const child of root.children) {
+    if (child.type === "export_statement") {
+      for (const gc of child.children) recordCallable(gc);
+    } else {
+      recordCallable(child);
+    }
+  }
   const jsxElements = /* @__PURE__ */ new Set();
   const jsxQuery = getQuery("jsx-elements");
   const jsxCaptures = jsxQuery.captures(root);
@@ -446,7 +475,7 @@ function parseFileTS(absPath) {
     }
   }
   const name = defaultName ?? firstValueExport ?? firstTypeExport ?? "";
-  return { name, exports: exportsOrdered, imports, reExports, jsxElements, navigations, fetchCalls };
+  return { name, exports: exportsOrdered, defines: [...definesSet], imports, reExports, jsxElements, navigations, fetchCalls };
 }
 function extractDbCallsTS(absPath) {
   const tree = parseSource(absPath);
@@ -2884,6 +2913,11 @@ function generate(rootDir) {
     const parsed = parsedByPath.get(absPath);
     const name = parsed.name || nameFromFilename(absPath);
     const layer = CLASSIFICATION_TO_LAYER[type] ?? "ui";
+    const importedNames = [...new Set(
+      parsed.imports.flatMap(
+        (imp) => imp.isTypeOnly ? [] : imp.names.filter((n) => !imp.typeNames.has(n))
+      )
+    )];
     nodeIdSet.add(id);
     if (layer === "api") {
       const dbCalls = extractDbCallsTS(absPath);
@@ -2922,6 +2956,8 @@ function generate(rootDir) {
         responses: deep.responses,
         params: deep.params,
         ...deep.effects ? { effects: deep.effects } : {},
+        ...parsed.defines.length > 0 ? { defines: parsed.defines } : {},
+        ...importedNames.length > 0 ? { imported_names: importedNames } : {},
         ...deep.notes ? { notes: deep.notes } : {},
         _dbCalls: dbCalls
         // temp: used for cross-ref building below
@@ -2938,6 +2974,8 @@ function generate(rootDir) {
         layer: "ui",
         route,
         exports: parsed.exports,
+        ...parsed.defines.length > 0 ? { defines: parsed.defines } : {},
+        ...importedNames.length > 0 ? { imported_names: importedNames } : {},
         elements: deep.elements,
         stateVars: deep.stateVars,
         conditions: deep.conditions,
@@ -5898,6 +5936,132 @@ var middlewareGatesParser = {
   }
 };
 
+// src/server/graph/parsers/crosslayer/call-resolver.ts
+var BARE_IDENT = /^[A-Za-z_$][\w$]*$/;
+var callResolverParser = {
+  id: "call-resolver",
+  layer: "crosslayer",
+  concern: "call-graph",
+  detect(_rootDir) {
+    return true;
+  },
+  generate(_rootDir, layerOutputs) {
+    const definers = /* @__PURE__ */ new Map();
+    const addDef = (sym, entry) => {
+      if (!BARE_IDENT.test(sym)) return;
+      const list = definers.get(sym);
+      if (!list) {
+        definers.set(sym, [entry]);
+      } else if (!list.some((d) => d.nodeId === entry.nodeId)) {
+        list.push(entry);
+      }
+    };
+    const nodeLayer = /* @__PURE__ */ new Map();
+    for (const [layer, output] of layerOutputs) {
+      if (layer === "db" || layer === "static") continue;
+      for (const node of output.nodes) {
+        nodeLayer.set(node.id, layer);
+        const entry = { nodeId: node.id, layer };
+        for (const s of node.exports ?? []) addDef(s, entry);
+        for (const s of node.defines ?? []) addDef(s, entry);
+      }
+    }
+    const importTargets = /* @__PURE__ */ new Map();
+    for (const [, output] of layerOutputs) {
+      for (const e of output.edges) {
+        if (e.type !== "imports" && e.type !== "imports_type" && e.type !== "renders") continue;
+        let set = importTargets.get(e.source);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          importTargets.set(e.source, set);
+        }
+        set.add(e.target);
+      }
+    }
+    const crossRefs = [];
+    const seen = /* @__PURE__ */ new Set();
+    let resolvedSelf = 0;
+    let resolvedImport = 0;
+    let ambiguous = 0;
+    let dropped = 0;
+    for (const [, output] of layerOutputs) {
+      for (const node of output.nodes) {
+        const calls = node.effects?.calls;
+        if (!calls || calls.length === 0) continue;
+        const selfSyms = /* @__PURE__ */ new Set([
+          ...node.exports ?? [],
+          ...node.defines ?? []
+        ]);
+        const importedSyms = new Set(node.imported_names ?? []);
+        const myImports = importTargets.get(node.id);
+        const localSeen = /* @__PURE__ */ new Set();
+        for (const callee of calls) {
+          if (!BARE_IDENT.test(callee)) continue;
+          if (localSeen.has(callee)) continue;
+          localSeen.add(callee);
+          const key = `${node.id}\u2192${callee}`;
+          if (selfSyms.has(callee)) {
+            if (seen.has(key)) continue;
+            seen.add(key);
+            crossRefs.push({
+              source: node.id,
+              target: callee,
+              type: "calls",
+              layer: nodeLayer.get(node.id) ?? "ui",
+              defined_in: node.id
+            });
+            resolvedSelf++;
+            continue;
+          }
+          if (!importedSyms.has(callee)) {
+            dropped++;
+            continue;
+          }
+          const defs = (definers.get(callee) ?? []).filter((d) => d.nodeId !== node.id);
+          if (defs.length === 0) {
+            dropped++;
+            continue;
+          }
+          const fromImported = myImports ? defs.filter((d) => myImports.has(d.nodeId)) : [];
+          const chosen = fromImported.length > 0 ? fromImported : defs;
+          const owner = chosen[0];
+          const isAmbiguous = chosen.length > 1;
+          if (isAmbiguous) ambiguous++;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          const ref = {
+            source: node.id,
+            target: callee,
+            type: "calls",
+            layer: owner.layer,
+            defined_in: owner.nodeId
+          };
+          if (isAmbiguous) ref.ambiguous = true;
+          crossRefs.push(ref);
+          resolvedImport++;
+        }
+      }
+    }
+    crossRefs.sort(
+      (a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target)
+    );
+    return {
+      cross_refs: crossRefs,
+      flagged_edges: [],
+      warnings: [],
+      patterns: {
+        call_resolution: {
+          resolved_self: resolvedSelf,
+          resolved_import: resolvedImport,
+          ambiguous,
+          dropped,
+          symbols_defined: definers.size
+        }
+      }
+    };
+  }
+};
+
 // src/server/graph/core/parser-registry.ts
 function isMultiLayerParser(p) {
   return "layers" in p && Array.isArray(p.layers);
@@ -5964,7 +6128,8 @@ function registerBuiltins2(registry, disabled) {
     apiAnnotationsParser,
     urlLiteralScannerParser,
     staticRefScannerParser,
-    middlewareGatesParser
+    middlewareGatesParser,
+    callResolverParser
   ];
   for (const parser of builtins) {
     if (disabled.has(parser.id)) continue;