@launchsecure/launch-kit 0.0.33 → 0.0.35

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/orbit-entry.js

@@ -1530,6 +1530,73 @@ var init_manifest = __esm({
   }
 });
 
+// src/server/orbit/active.ts
+function anchorPaths(projectRoot) {
+  const dir = (0, import_node_path7.join)(projectRoot, LAUNCHSECURE_DIR, "orbit");
+  return { dir, current: (0, import_node_path7.join)(dir, "current"), activeJson: (0, import_node_path7.join)(dir, "active.json") };
+}
+function present(p) {
+  try {
+    (0, import_node_fs10.lstatSync)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setActiveOrbit(entry, envFileName) {
+  const paths = anchorPaths(entry.projectRoot);
+  (0, import_node_fs10.mkdirSync)(paths.dir, { recursive: true });
+  const tmpLink = `${paths.current}.tmp.${process.pid}`;
+  if (present(tmpLink)) (0, import_node_fs10.rmSync)(tmpLink, { force: true });
+  (0, import_node_fs10.symlinkSync)(entry.path, tmpLink);
+  (0, import_node_fs10.renameSync)(tmpLink, paths.current);
+  const active = {
+    slug: entry.slug,
+    branch: entry.branch,
+    path: entry.path,
+    envFile: (0, import_node_path7.join)(entry.path, envFileName),
+    projectRoot: entry.projectRoot,
+    anchor: paths.current,
+    switchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmpJson = `${paths.activeJson}.tmp.${process.pid}`;
+  (0, import_node_fs10.writeFileSync)(tmpJson, JSON.stringify(active, null, 2) + "\n", "utf-8");
+  (0, import_node_fs10.renameSync)(tmpJson, paths.activeJson);
+  return active;
+}
+function clearActiveOrbit(projectRoot) {
+  const paths = anchorPaths(projectRoot);
+  let cleared = false;
+  for (const p of [paths.current, paths.activeJson]) {
+    if (present(p)) {
+      try {
+        (0, import_node_fs10.rmSync)(p, { force: true });
+        cleared = true;
+      } catch {
+      }
+    }
+  }
+  return cleared;
+}
+function readActiveOrbit(projectRoot) {
+  const { activeJson } = anchorPaths(projectRoot);
+  if (!present(activeJson)) return null;
+  try {
+    return JSON.parse((0, import_node_fs10.readFileSync)(activeJson, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var import_node_fs10, import_node_path7;
+var init_active = __esm({
+  "src/server/orbit/active.ts"() {
+    "use strict";
+    import_node_fs10 = require("node:fs");
+    import_node_path7 = require("node:path");
+    init_launch_kit_paths();
+  }
+});
+
 // src/server/orbit/slug.ts
 function slugify(branch) {
   let s = branch.toLowerCase();
@@ -1556,7 +1623,7 @@ async function create(opts) {
   const envFileName = opts.envFileName ?? manifest.envFile ?? DEFAULT_ENV_FILE;
   const ctx = {
     projectRoot: opts.projectRoot,
-    manifestPath: (0, import_node_path7.join)(opts.projectRoot, "orbit.json"),
+    manifestPath: (0, import_node_path8.join)(opts.projectRoot, "orbit.json"),
     manifest,
     logger: opts.logger,
     envFileName
@@ -1610,13 +1677,13 @@ async function create(opts) {
         Object.assign(rewriteFns, adapter.envRewrites(state, ctx));
       }
     }
-    const srcEnv = (0, import_node_path7.join)(opts.projectRoot, envFileName);
-    const dstEnv = (0, import_node_path7.join)(worktreeState.path, envFileName);
-    if ((0, import_node_fs10.existsSync)(srcEnv) && !(0, import_node_fs10.existsSync)(dstEnv)) {
+    const srcEnv = (0, import_node_path8.join)(opts.projectRoot, envFileName);
+    const dstEnv = (0, import_node_path8.join)(worktreeState.path, envFileName);
+    if ((0, import_node_fs11.existsSync)(srcEnv) && !(0, import_node_fs11.existsSync)(dstEnv)) {
       opts.logger.step(`copy ${envFileName} into worktree`);
       copyEnvFile(srcEnv, dstEnv);
     }
-    if ((0, import_node_fs10.existsSync)(dstEnv) && Object.keys(rewriteFns).length > 0) {
+    if ((0, import_node_fs11.existsSync)(dstEnv) && Object.keys(rewriteFns).length > 0) {
       opts.logger.step(`rewrite ${envFileName} (${Object.keys(rewriteFns).join(", ")})`);
       const r = rewriteEnvFile(dstEnv, rewriteFns);
       if (r.missing.length > 0) {
@@ -1636,7 +1703,7 @@ async function create(opts) {
     opts.logger.ok(`registered ${slug}`);
     try {
       opts.logger.step(`generate chart graph for worktree`);
-      const chartEntry = (0, import_node_path7.join)(__dirname, "graph-mcp-entry.js");
+      const chartEntry = (0, import_node_path8.join)(__dirname, "graph-mcp-entry.js");
       const result = (0, import_node_child_process8.spawnSync)(
         process.execPath,
         [chartEntry, "generate"],
@@ -1688,7 +1755,7 @@ async function drop(opts) {
   const manifest = loadManifestOrThrow(opts.projectRoot);
   const ctx = {
     projectRoot: opts.projectRoot,
-    manifestPath: (0, import_node_path7.join)(opts.projectRoot, "orbit.json"),
+    manifestPath: (0, import_node_path8.join)(opts.projectRoot, "orbit.json"),
     manifest,
     logger: opts.logger,
     envFileName: manifest.envFile ?? DEFAULT_ENV_FILE
@@ -1709,7 +1776,7 @@ async function drop(opts) {
     if (result.backupPath) backups[ref.name] = result.backupPath;
     freed[ref.name] = state.state;
   }
-  if ((0, import_node_fs10.existsSync)(entry.path)) {
+  if ((0, import_node_fs11.existsSync)(entry.path)) {
     const blockers = findBlockingPids(entry.path);
     if (blockers.length > 0) {
       opts.logger.warn(`${blockers.length} process(es) holding files in worktree \u2014 terminating:`);
@@ -1728,15 +1795,19 @@ async function drop(opts) {
   } catch (e) {
     opts.logger.warn(`worktree remove failed (continuing anyway): ${e.message}`);
   }
-  if ((0, import_node_fs10.existsSync)(entry.path)) {
+  if ((0, import_node_fs11.existsSync)(entry.path)) {
     opts.logger.step(`remove leftover dir at ${entry.path}`);
     try {
-      (0, import_node_fs10.rmSync)(entry.path, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(entry.path, { recursive: true, force: true });
     } catch (e) {
       opts.logger.warn(`leftover dir cleanup failed: ${e.message}`);
     }
   }
   await deregisterWorktree(slug);
+  if (readActiveOrbit(opts.projectRoot)?.slug === slug) {
+    clearActiveOrbit(opts.projectRoot);
+    opts.logger.step("cleared active-orbit anchor (current)");
+  }
   opts.logger.ok(`dropped ${slug}`);
   return { slug, backups, freed };
 }
@@ -1753,12 +1824,19 @@ function switchTo(opts) {
   const slug = slugify(opts.branch);
   const entry = lookupWorktree(slug);
   if (!entry) throw new Error(`no orbit registered for branch "${opts.branch}" (slug ${slug})`);
+  const active = setActiveOrbit(entry, DEFAULT_ENV_FILE);
   return {
     path: entry.path,
-    envFile: (0, import_node_path7.join)(entry.path, DEFAULT_ENV_FILE),
+    envFile: active.envFile,
+    anchor: active.anchor,
+    activeJson: anchorPaths(entry.projectRoot).activeJson,
+    nextAction: `cd "${active.anchor}"`,
     entry
   };
 }
+function deactivate(opts) {
+  return { cleared: clearActiveOrbit(opts.projectRoot), projectRoot: opts.projectRoot };
+}
 function doctor() {
   const issues = [];
   const trackedByRoot = /* @__PURE__ */ new Map();
@@ -1781,7 +1859,7 @@ function doctor() {
     return s;
   };
   for (const w of listWorktrees()) {
-    if (!(0, import_node_fs10.existsSync)(w.path)) {
+    if (!(0, import_node_fs11.existsSync)(w.path)) {
       issues.push({ kind: "missing-worktree", slug: w.slug, detail: `path ${w.path} does not exist` });
       continue;
     }
@@ -2018,18 +2096,19 @@ function formatAge(iso) {
   const d = Math.floor(h / 24);
   return `${d}d`;
 }
-var import_node_child_process8, import_node_fs10, import_node_path7, DEFAULT_ENV_FILE;
+var import_node_child_process8, import_node_fs11, import_node_path8, DEFAULT_ENV_FILE;
 var init_orchestrator = __esm({
   "src/server/orbit/orchestrator.ts"() {
     "use strict";
     import_node_child_process8 = require("node:child_process");
-    import_node_fs10 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_fs11 = require("node:fs");
+    import_node_path8 = require("node:path");
     init_adapter_registry();
     init_env_rewriter();
     init_gate_runner();
     init_manifest();
     init_registry();
+    init_active();
     init_slug();
     DEFAULT_ENV_FILE = ".env.local";
   }
@@ -2093,11 +2172,16 @@ async function handleTool(name, args) {
       const result = switchTo({ branch, projectRoot });
       return text({
         slug: result.entry.slug,
+        branch: result.entry.branch,
+        anchor: result.anchor,
         path: result.path,
         envFile: result.envFile,
-        nextAction: `cd ${result.path}`
+        nextAction: result.nextAction
       });
     }
+    case "orbit.deactivate": {
+      return text(deactivate({ projectRoot }));
+    }
     case "orbit.drop": {
       const branch = String(args.branch ?? "");
       if (!branch) return text({ error: "branch is required" });
@@ -2256,15 +2340,20 @@ var init_orbit_mcp = __esm({
       },
       {
         name: "orbit.switch",
-        description: "Look up the path + env file of an existing orbit by branch name. Does NOT change any shell \u2014 the caller is expected to `cd` into the returned path. Useful for agents that need to operate inside an already-created orbit.",
+        description: 'Activate an orbit by branch name. Atomically repoints the stable anchor <project>/.launchsecure/orbit/current at the orbit\'s worktree and records active.json, then returns `anchor` (the current/ path) + `nextAction`. AFTER calling this, operate on the anchor: Read/Edit/Write under `.launchsecure/orbit/current/<path>`, pass `project_root: ".launchsecure/orbit/current"` to chart, and run the returned `nextAction` (cd into current) so commands execute in the orbit. Switching to a different orbit just repoints the anchor; re-run nextAction afterwards.',
         inputSchema: {
           type: "object",
           properties: {
-            branch: { type: "string", description: "Branch name to look up." }
+            branch: { type: "string", description: "Branch name of the orbit to activate." }
           },
           required: ["branch"]
         }
       },
+      {
+        name: "orbit.deactivate",
+        description: "Clear the active-orbit anchor for this project \u2014 removes <project>/.launchsecure/orbit/current and active.json so no orbit is active. Use when you're done working in an orbit and want subsequent work to target the main checkout. No-op if nothing is active.",
+        inputSchema: { type: "object", properties: {} }
+      },
       {
         name: "orbit.drop",
         description: "Tear down an orbit: backup the database (default true), drop the database, terminate any process holding files inside the worktree (chart/beacon MCPs, dev servers \u2014 via lsof+SIGTERM), remove the worktree, sweep any leftover on-disk dir, deregister. Idempotent: safe to retry on a partial state (e.g. git already removed the worktree but the registry still claims it). Returns { slug, backups, freed }.",
@@ -2326,8 +2415,8 @@ var init_orbit_mcp = __esm({
 });
 
 // src/server/orbit-entry.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path9 = require("node:path");
 init_orchestrator();
 init_logger();
 function parseFlags(argv) {
@@ -2413,14 +2502,22 @@ ${JSON.stringify(result, null, 2)}
         if (!branch) die("usage: launch-orbit switch <branch> [--emit-cd]");
         const result = switchTo({ branch, projectRoot });
         if (flags.emitCd) {
-          process.stdout.write(`cd ${result.path}
+          process.stdout.write(`cd ${result.anchor}
 `);
         } else {
-          process.stdout.write(`${JSON.stringify({ path: result.path, envFile: result.envFile, nextAction: `cd ${result.path}` }, null, 2)}
-`);
+          process.stdout.write(
+            `${JSON.stringify({ anchor: result.anchor, path: result.path, envFile: result.envFile, nextAction: result.nextAction }, null, 2)}
+`
+          );
         }
         return;
       }
+      case "deactivate": {
+        const result = deactivate({ projectRoot });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
       case "drop": {
         const branch = positional[0];
         if (!branch) die("usage: launch-orbit drop <branch> [--no-backup]");
@@ -2495,8 +2592,8 @@ ${JSON.stringify(result, null, 2)}
   }
 }
 function runInit(projectRoot) {
-  const path = (0, import_node_path8.join)(projectRoot, "orbit.json");
-  if ((0, import_node_fs11.existsSync)(path)) {
+  const path = (0, import_node_path9.join)(projectRoot, "orbit.json");
+  if ((0, import_node_fs12.existsSync)(path)) {
     process.stderr.write(`[launch-orbit] orbit.json already exists at ${path}
 `);
     process.exit(1);
@@ -2551,7 +2648,7 @@ function runInit(projectRoot) {
       full: { resources: ["db", "ports"] }
     }
   };
-  (0, import_node_fs11.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
+  (0, import_node_fs12.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
   process.stdout.write(`\u2713 wrote ${path}
 `);
 }

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;