@launchsecure/launch-kit 0.0.32 → 0.0.34

package/dist/server/launch-radar-entry.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/server/launch-radar-entry.ts
+var import_node_child_process = require("node:child_process");
+var import_node_path = __toESM(require("node:path"));
+var sequencerEntry = import_node_path.default.join(__dirname, "cli.js");
+var child = (0, import_node_child_process.spawn)(process.execPath, [sequencerEntry, "radar", ...process.argv.slice(2)], {
+  stdio: "inherit"
+});
+var forward = (sig) => () => {
+  try {
+    child.kill(sig);
+  } catch {
+  }
+};
+process.on("SIGTERM", forward("SIGTERM"));
+process.on("SIGINT", forward("SIGINT"));
+process.on("SIGHUP", forward("SIGHUP"));
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});

package/dist/server/parse-worker-entry.js

@@ -346,6 +346,7 @@ function emptyParsedFile(absPath) {
   return {
     name: absPath.split("/").pop() ?? absPath,
     exports: [],
+    defines: [],
     imports: [],
     reExports: [],
     jsxElements: /* @__PURE__ */ new Set(),
@@ -458,6 +459,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);
@@ -546,7 +575,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);
@@ -2041,6 +2070,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);
@@ -2079,6 +2113,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
@@ -2095,6 +2131,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,
@@ -5048,6 +5086,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);
@@ -5114,7 +5278,8 @@ function registerBuiltins(registry, disabled) {
     apiAnnotationsParser,
     urlLiteralScannerParser,
     staticRefScannerParser,
-    middlewareGatesParser
+    middlewareGatesParser,
+    callResolverParser
   ];
   for (const parser of builtins) {
     if (disabled.has(parser.id)) continue;