@saptools/service-flow 0.1.50 → 0.1.52

package/dist/{chunk-52OUS3MO.js → chunk-PTLDSHRC.js}

@@ -1,5 +1,468 @@
 #!/usr/bin/env node
 
+// src/db/repositories.ts
+function upsertWorkspace(db, rootPath, dbPath) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    "INSERT INTO workspaces(root_path,db_path,created_at,updated_at) VALUES(?,?,?,?) ON CONFLICT(root_path) DO UPDATE SET db_path=excluded.db_path,updated_at=excluded.updated_at"
+  ).run(rootPath, dbPath, now, now);
+  return Number(
+    db.prepare("SELECT id FROM workspaces WHERE root_path=?").get(rootPath)?.id
+  );
+}
+function getWorkspace(db, rootPath) {
+  return db.prepare("SELECT * FROM workspaces WHERE root_path=?").get(rootPath);
+}
+function upsertRepository(db, workspaceId, r) {
+  db.prepare(
+    `INSERT INTO repositories(workspace_id,name,absolute_path,relative_path,package_name,package_version,dependencies_json,kind,is_git_repo) VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(workspace_id,absolute_path) DO UPDATE SET name=excluded.name,relative_path=excluded.relative_path,package_name=excluded.package_name,package_version=excluded.package_version,dependencies_json=excluded.dependencies_json,kind=excluded.kind`
+  ).run(
+    workspaceId,
+    r.name,
+    r.absolutePath,
+    r.relativePath,
+    r.packageName,
+    r.packageVersion,
+    JSON.stringify(r.dependencies ?? {}),
+    r.kind ?? "unknown",
+    r.isGitRepo ? 1 : 0
+  );
+  return Number(
+    db.prepare(
+      "SELECT id FROM repositories WHERE workspace_id=? AND absolute_path=?"
+    ).get(workspaceId, r.absolutePath)?.id
+  );
+}
+function listRepositories(db, workspaceId) {
+  return db.prepare("SELECT * FROM repositories WHERE (? IS NULL OR workspace_id=?) ORDER BY name,absolute_path,id").all(workspaceId, workspaceId);
+}
+function reposByName(db, name, workspaceId) {
+  return db.prepare(`SELECT * FROM repositories
+      WHERE (? IS NULL OR workspace_id=?) AND (name=? OR package_name=?)
+      ORDER BY name,absolute_path,id`).all(workspaceId, workspaceId, name, name);
+}
+function clearRepoFacts(db, repoId) {
+  for (const t of [
+    "cds_requires",
+    "cds_services",
+    "handler_classes",
+    "outbound_calls",
+    "symbol_calls",
+    "handler_registrations",
+    "service_bindings",
+    "symbols",
+    "diagnostics",
+    "files"
+  ])
+    db.prepare(`DELETE FROM ${t} WHERE repo_id=?`).run(repoId);
+  db.prepare("DELETE FROM search_index WHERE repo=?").run(String(repoId));
+}
+function insertRequires(db, repoId, rows2) {
+  const stmt = db.prepare(
+    "INSERT INTO cds_requires(repo_id,alias,kind,model,destination,service_path,request_timeout,raw_json) VALUES(?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows2)
+    stmt.run(
+      repoId,
+      r.alias,
+      r.kind,
+      r.model,
+      r.destination,
+      r.servicePath,
+      r.requestTimeout,
+      r.rawJson
+    );
+}
+function insertService(db, repoId, s) {
+  const id = Number(
+    db.prepare(
+      "INSERT INTO cds_services(repo_id,namespace,service_name,qualified_name,service_path,is_extend,source_file,source_line,extension_local_ref,extension_imported_symbol,extension_local_alias,extension_module_specifier,extension_import_kind) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?) RETURNING id"
+    ).get(
+      repoId,
+      s.namespace,
+      s.serviceName,
+      s.qualifiedName,
+      s.servicePath,
+      s.isExtend ? 1 : 0,
+      s.sourceFile,
+      s.sourceLine,
+      s.extension?.localReference,
+      s.extension?.importedSymbol,
+      s.extension?.localAlias,
+      s.extension?.moduleSpecifier,
+      s.extension?.importKind
+    )?.id
+  );
+  const stmt = db.prepare(
+    "INSERT INTO cds_operations(service_id,operation_type,operation_name,operation_path,params_json,return_type,source_file,source_line,provenance,base_operation_id) VALUES(?,?,?,?,?,?,?,?,?,?)"
+  );
+  db.prepare(
+    "INSERT INTO search_index(kind,name,path,repo) VALUES(?,?,?,?)"
+  ).run("service", s.qualifiedName, s.servicePath, String(repoId));
+  for (const o of s.operations)
+    stmt.run(
+      id,
+      o.operationType,
+      o.operationName,
+      o.operationPath,
+      o.paramsJson,
+      o.returnType,
+      o.sourceFile,
+      o.sourceLine,
+      o.provenance ?? "direct",
+      o.baseOperationId ?? null
+    );
+  const search = db.prepare(
+    "INSERT INTO search_index(kind,name,path,repo) VALUES(?,?,?,?)"
+  );
+  for (const o of s.operations)
+    search.run("operation", o.operationName, o.operationPath, String(repoId));
+  return id;
+}
+function insertHandler(db, repoId, h) {
+  const sid = insertHandlerClassSymbol(db, repoId, h);
+  const hid = Number(
+    db.prepare(
+      "INSERT INTO handler_classes(repo_id,symbol_id,class_name,source_file,source_line) VALUES(?,?,?,?,?) RETURNING id"
+    ).get(repoId, sid, h.className, h.sourceFile, h.sourceLine)?.id
+  );
+  const stmt = db.prepare(
+    "INSERT INTO handler_methods(handler_class_id,method_name,decorator_kind,decorator_value,decorator_raw_expression,decorator_resolution_json,source_file,source_line) VALUES(?,?,?,?,?,?,?,?)"
+  );
+  for (const m of h.methods)
+    stmt.run(
+      hid,
+      m.methodName,
+      m.decoratorKind,
+      m.decoratorValue,
+      m.decoratorRawExpression,
+      JSON.stringify(canonicalHandlerMethodResolution(m)),
+      m.sourceFile,
+      m.sourceLine
+    );
+  insertHandlerIndexDiagnostic(db, repoId, h);
+  return hid;
+}
+function insertHandlerClassSymbol(db, repoId, h) {
+  const classEvidence = {
+    hasHandlerDecorator: h.hasHandlerDecorator ?? false,
+    classDecoratorNames: h.classDecoratorNames ?? [],
+    observedDecoratorNames: h.observedDecoratorNames ?? [],
+    unsupportedDecoratorNames: h.unsupportedDecoratorNames ?? [],
+    unsupportedMethods: h.methods.filter((method) => !handlerMethodIsExecutable(method)).map((method) => ({
+      methodName: method.methodName,
+      decoratorKind: method.decoratorKind,
+      sourceFile: method.sourceFile,
+      sourceLine: method.sourceLine,
+      reason: method.decoratorResolution.unresolvedReason
+    }))
+  };
+  return Number(
+    db.prepare(
+      "INSERT INTO symbols(repo_id,kind,name,qualified_name,exported,start_line,end_line,source_file,evidence_json) VALUES(?,?,?,?,?,?,?,?,?) RETURNING id"
+    ).get(
+      repoId,
+      "class",
+      h.className,
+      h.className,
+      1,
+      h.sourceLine,
+      h.sourceLine,
+      h.sourceFile,
+      JSON.stringify(classEvidence)
+    )?.id
+  );
+}
+function insertHandlerIndexDiagnostic(db, repoId, h) {
+  if (!h.hasHandlerDecorator) return;
+  const hasExecutable = h.methods.some(handlerMethodIsExecutable);
+  const unsupported = h.methods.filter((method) => !handlerMethodIsExecutable(method));
+  if (hasExecutable && unsupported.length === 0) return;
+  const code = hasExecutable ? "handler_decorators_not_indexed" : "handler_methods_not_indexed";
+  const names = unsupported.map((method) => method.decoratorKind).sort();
+  const detail = names.length > 0 ? ` Unsupported decorators: ${[...new Set(names)].join(", ")}.` : "";
+  db.prepare(
+    "INSERT INTO diagnostics(repo_id,severity,code,message,source_file,source_line) VALUES(?,?,?,?,?,?)"
+  ).run(
+    repoId,
+    "warning",
+    code,
+    hasExecutable ? `Handler class ${h.className} contains methods that were not indexed.${detail}` : `Handler class ${h.className} has no indexed executable methods; use a supported CAP handler decorator and re-index.${detail}`,
+    h.sourceFile,
+    h.sourceLine
+  );
+}
+function canonicalHandlerMethodResolution(method) {
+  const handlerKind = method.handlerKind ?? method.decoratorResolution.handlerKind ?? legacyHandlerKind(method.decoratorKind);
+  const executable = method.executable ?? method.decoratorResolution.executable ?? (handlerKind === "operation" || handlerKind === "event" || handlerKind === "entity_lifecycle");
+  return {
+    ...method.decoratorResolution,
+    handlerKind,
+    executable,
+    lifecyclePhase: method.lifecyclePhase ?? method.decoratorResolution.lifecyclePhase,
+    lifecycleEvent: method.lifecycleEvent ?? method.decoratorResolution.lifecycleEvent
+  };
+}
+function handlerMethodIsExecutable(method) {
+  return canonicalHandlerMethodResolution(method).executable === true;
+}
+function legacyHandlerKind(kind) {
+  if (kind === "Event") return "event";
+  if (["Action", "Func", "On"].includes(kind)) return "operation";
+  return "unsupported_decorator";
+}
+function insertRegistrations(db, repoId, rows2) {
+  const stmt = db.prepare(
+    "INSERT INTO handler_registrations(repo_id,handler_class_id,class_name,import_source,registration_file,registration_line,registration_kind,confidence) VALUES(?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows2) {
+    const handlerClass = r.className ? db.prepare(
+      "SELECT id FROM handler_classes WHERE repo_id=? AND class_name=? ORDER BY id"
+    ).all(repoId, r.className) : [];
+    stmt.run(
+      repoId,
+      handlerClass.length === 1 ? handlerClass[0]?.id : null,
+      r.className,
+      r.importSource,
+      r.registrationFile,
+      r.registrationLine,
+      r.registrationKind,
+      r.confidence
+    );
+  }
+}
+function insertBindings(db, repoId, rows2) {
+  const stmt = db.prepare(
+    "INSERT INTO service_bindings(repo_id,symbol_id,variable_name,alias,alias_expr,destination_expr,service_path_expr,is_dynamic,placeholders_json,source_file,source_line,helper_chain_json) VALUES(?,(SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND start_line<=? AND end_line>=? ORDER BY (end_line-start_line),id LIMIT 1),?,?,?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows2)
+    stmt.run(
+      repoId,
+      repoId,
+      r.sourceFile,
+      r.sourceLine,
+      r.sourceLine,
+      r.variableName,
+      r.alias,
+      r.aliasExpr,
+      r.destinationExpr,
+      r.servicePathExpr,
+      r.isDynamic ? 1 : 0,
+      JSON.stringify(r.placeholders),
+      r.sourceFile,
+      r.sourceLine,
+      r.helperChain ? JSON.stringify(r.helperChain) : null
+    );
+}
+function insertExecutableSymbols(db, repoId, rows2) {
+  const stmt = db.prepare("INSERT INTO symbols(repo_id,file_id,kind,name,qualified_name,exported,start_line,end_line,start_offset,end_offset,source_file,exported_name,evidence_json) VALUES(?,(SELECT id FROM files WHERE repo_id=? AND relative_path=?),?,?,?,?,?,?,?,?,?,?,?)");
+  for (const r of rows2) stmt.run(repoId, repoId, r.sourceFile, r.kind, r.localName, r.qualifiedName, r.exported ? 1 : 0, r.startLine, r.endLine, r.startOffset, r.endOffset, r.sourceFile, r.exportedName, r.importExportEvidence ? JSON.stringify(r.importExportEvidence) : null);
+}
+function insertSymbolCalls(db, repoId, rows2) {
+  const callerStmt = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1");
+  const insertStmt = db.prepare("INSERT INTO symbol_calls(repo_id,caller_symbol_id,callee_symbol_id,callee_expression,import_source,source_file,source_line,status,confidence,evidence_json,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?)");
+  for (const r of rows2) {
+    const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName);
+    const target = resolveSymbolCallTarget(db, repoId, r);
+    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount }), target.reason);
+  }
+}
+function isRelativeImportedSymbolCall(r) {
+  return Boolean(r.importSource?.startsWith("."));
+}
+function resolveSymbolCallTarget(db, repoId, r) {
+  const evidence = r.evidence;
+  const localRows = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName);
+  if (localRows.length === 1) return { id: localRows[0]?.id ?? null, status: "resolved", reason: null, strategy: "same_file_exact", candidateCount: 1 };
+  if (localRows.length > 1) return { id: null, status: "ambiguous", reason: "Multiple same-file symbol targets matched exactly", strategy: "same_file_exact", candidateCount: localRows.length };
+  if (evidence.relation === "class_instance_method" && isRelativeImportedSymbolCall(r)) {
+    const classRows = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName);
+    if (classRows.length === 1) return { id: classRows[0]?.id ?? null, status: "resolved", reason: null, strategy: "relative_import_class_instance_method", candidateCount: 1 };
+    if (classRows.length > 1) return { id: null, status: "ambiguous", reason: "Multiple relative class instance method targets matched exactly", strategy: "relative_import_class_instance_method", candidateCount: classRows.length };
+  }
+  const rows2 = db.prepare("SELECT id,kind,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName);
+  if (evidence.relation === "relative_import_proxy_member" && rows2.length > 1) {
+    const objectMapRows = rows2.filter((row) => String(row.evidenceJson ?? "").includes("exported_object_shorthand") || String(row.evidenceJson ?? "").includes("exported_object_literal"));
+    if (objectMapRows.length > 0) {
+      const concrete = rows2.find((row) => row.kind !== "object_alias") ?? objectMapRows[0];
+      return { id: concrete?.id ?? null, status: "resolved", reason: null, strategy: "proxy_member_exported_object_map", candidateCount: rows2.length };
+    }
+    return { id: null, status: "ambiguous", reason: "Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous", strategy: "proxy_member_no_global_name_fallback", candidateCount: rows2.length };
+  }
+  if (rows2.length === 1) return { id: rows2[0]?.id ?? null, status: "resolved", reason: null, strategy: evidence.relation === "relative_import_proxy_member" ? "proxy_member_unique_exported_candidate" : "relative_import_exported_exact", candidateCount: 1 };
+  if (rows2.length > 1) return { id: null, status: "ambiguous", reason: "Multiple exported symbol targets matched exactly", strategy: "exported_exact", candidateCount: rows2.length };
+  return { id: null, status: "unresolved", reason: "No local symbol target matched exactly", strategy: evidence.relation === "relative_import_proxy_member" ? "proxy_member_no_global_name_fallback" : "exact_symbol_match", candidateCount: 0 };
+}
+function insertCalls(db, repoId, rows2) {
+  const stmt = db.prepare(
+    "INSERT INTO outbound_calls(repo_id,source_symbol_id,call_type,method,operation_path_expr,query_entity,event_name_expr,payload_summary,source_file,source_line,confidence,unresolved_reason,local_service_name,local_service_lookup,alias_chain_json,evidence_json,external_target_kind,external_target_id,external_target_label,external_target_dynamic,service_binding_id) VALUES(?,COALESCE((SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1),(SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND start_line<=? AND end_line>=? ORDER BY (end_line-start_line),id LIMIT 1)),?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows2) {
+    const binding = resolvePersistedBinding(db, repoId, r);
+    const evidence = {
+      ...r.evidence ?? {},
+      serviceBindingResolution: binding.evidence
+    };
+    stmt.run(
+      repoId,
+      repoId,
+      r.sourceFile,
+      r.sourceSymbolQualifiedName,
+      repoId,
+      r.sourceFile,
+      r.sourceLine,
+      r.sourceLine,
+      r.callType,
+      r.method,
+      r.operationPathExpr,
+      r.queryEntity,
+      r.eventNameExpr,
+      r.payloadSummary,
+      r.sourceFile,
+      r.sourceLine,
+      r.confidence,
+      r.unresolvedReason ?? binding.unresolvedReason,
+      r.localServiceName,
+      r.localServiceLookup,
+      r.aliasChain ? JSON.stringify(r.aliasChain) : null,
+      JSON.stringify(evidence),
+      r.externalTarget?.kind ?? null,
+      r.externalTarget?.stableId ?? null,
+      r.externalTarget?.label ?? null,
+      r.externalTarget?.dynamic ? 1 : 0,
+      binding.bindingId
+    );
+  }
+}
+function resolvePersistedBinding(db, repoId, call) {
+  if (!call.serviceVariableName)
+    return { bindingId: null, evidence: { status: "not_applicable", candidateCount: 0 } };
+  const candidates = bindingCandidates(db, repoId, call);
+  const prior = candidates.filter((candidate) => candidate.sourceLine <= call.sourceLine);
+  const families = new Set(prior.map(bindingSignature));
+  if (prior.length > 0 && families.size === 1) {
+    const selected = prior.at(-1);
+    return {
+      bindingId: selected?.id ?? null,
+      evidence: bindingEvidence("selected", prior, selected)
+    };
+  }
+  if (prior.length > 1) {
+    return {
+      bindingId: null,
+      unresolvedReason: "ambiguous_service_binding_candidates",
+      evidence: bindingEvidence("ambiguous", prior)
+    };
+  }
+  if (candidates.length > 0) {
+    return {
+      bindingId: null,
+      unresolvedReason: "service_binding_declared_after_call",
+      evidence: bindingEvidence("rejected_future_binding", candidates)
+    };
+  }
+  return {
+    bindingId: null,
+    evidence: bindingEvidence("unrecoverable", [])
+  };
+}
+function bindingCandidates(db, repoId, call) {
+  const ownerId = callSymbolId(db, repoId, call);
+  const rows2 = db.prepare(`
+    SELECT id,symbol_id symbolId,variable_name variableName,alias,alias_expr aliasExpr,
+      destination_expr destinationExpr,service_path_expr servicePathExpr,
+      source_file sourceFile,source_line sourceLine,helper_chain_json helperChainJson
+    FROM service_bindings
+    WHERE repo_id=? AND variable_name=? AND source_file=?
+      AND (? IS NULL OR symbol_id IS NULL OR symbol_id=?)
+    ORDER BY source_line,id
+  `).all(
+    repoId,
+    call.serviceVariableName,
+    call.sourceFile,
+    ownerId,
+    ownerId
+  );
+  return rows2.flatMap((row) => {
+    if (typeof row.id !== "number" || typeof row.variableName !== "string" || typeof row.sourceFile !== "string" || typeof row.sourceLine !== "number")
+      return [];
+    return [{
+      id: row.id,
+      symbolId: nullableNumber(row.symbolId),
+      variableName: row.variableName,
+      alias: nullableString(row.alias),
+      aliasExpr: nullableString(row.aliasExpr),
+      destinationExpr: nullableString(row.destinationExpr),
+      servicePathExpr: nullableString(row.servicePathExpr),
+      sourceFile: row.sourceFile,
+      sourceLine: row.sourceLine,
+      helperChainJson: nullableString(row.helperChainJson)
+    }];
+  });
+}
+function nullableString(value) {
+  return value === null || typeof value === "string" ? value : void 0;
+}
+function nullableNumber(value) {
+  return value === null || typeof value === "number" ? value : void 0;
+}
+function callSymbolId(db, repoId, call) {
+  const row = db.prepare(`
+    SELECT id FROM symbols
+    WHERE repo_id=? AND source_file=?
+      AND ((? IS NOT NULL AND qualified_name=?)
+        OR (start_line<=? AND end_line>=?))
+    ORDER BY CASE WHEN qualified_name=? THEN 0 ELSE 1 END,
+      (end_line-start_line),id
+    LIMIT 1
+  `).get(
+    repoId,
+    call.sourceFile,
+    call.sourceSymbolQualifiedName,
+    call.sourceSymbolQualifiedName,
+    call.sourceLine,
+    call.sourceLine,
+    call.sourceSymbolQualifiedName
+  );
+  return typeof row?.id === "number" ? row.id : void 0;
+}
+function bindingEvidence(status, candidates, selected) {
+  return {
+    status,
+    candidateCount: candidates.length,
+    selectedBindingId: selected?.id,
+    sourceOrderRule: "binding_source_line_must_not_follow_call",
+    candidates: candidates.map((candidate) => ({
+      bindingId: candidate.id,
+      symbolId: candidate.symbolId,
+      variableName: candidate.variableName,
+      alias: candidate.alias,
+      aliasExpr: candidate.aliasExpr,
+      destinationExpr: candidate.destinationExpr,
+      servicePathExpr: candidate.servicePathExpr,
+      sourceFile: candidate.sourceFile,
+      sourceLine: candidate.sourceLine,
+      helperChain: parseBindingChain(candidate.helperChainJson)
+    }))
+  };
+}
+function bindingSignature(candidate) {
+  return JSON.stringify([
+    candidate.alias,
+    candidate.aliasExpr,
+    candidate.destinationExpr,
+    candidate.servicePathExpr
+  ]);
+}
+function parseBindingChain(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/discovery/discover-repositories.ts
 import fs from "fs/promises";
 import path2 from "path";
@@ -74,6 +537,9 @@ async function discoverRepositories(rootPath, ignore) {
 // src/parsers/package-json-parser.ts
 import fs2 from "fs/promises";
 import path3 from "path";
+function emptyPackageFacts() {
+  return { dependencies: {}, cdsRequires: [], scripts: {} };
+}
 function recordOfString(value) {
   if (!value || typeof value !== "object") return {};
   return Object.fromEntries(
@@ -100,22 +566,31 @@ function readRequires(cds) {
     ];
   });
 }
-async function parsePackageJson(repoPath) {
+async function parsePackageJson(repoPath, options = {}) {
+  return (await loadPackageJsonSnapshot(repoPath, options)).facts;
+}
+async function loadPackageJsonSnapshot(repoPath, options = {}) {
   try {
     const raw = await fs2.readFile(path3.join(repoPath, "package.json"), "utf8");
     const json = JSON.parse(raw);
     return {
-      packageName: typeof json.name === "string" ? json.name : void 0,
-      packageVersion: typeof json.version === "string" ? json.version : void 0,
-      dependencies: {
-        ...recordOfString(json.dependencies),
-        ...recordOfString(json.devDependencies)
-      },
-      cdsRequires: readRequires(json.cds),
-      scripts: recordOfString(json.scripts)
+      rawText: raw,
+      facts: {
+        packageName: typeof json.name === "string" ? json.name : void 0,
+        packageVersion: typeof json.version === "string" ? json.version : void 0,
+        dependencies: {
+          ...recordOfString(json.dependencies),
+          ...recordOfString(json.devDependencies)
+        },
+        cdsRequires: readRequires(json.cds),
+        scripts: recordOfString(json.scripts)
+      }
     };
-  } catch {
-    return { dependencies: {}, cdsRequires: [], scripts: {} };
+  } catch (error) {
+    const missing = typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    if (!options.strict || options.allowMissing && missing)
+      return { facts: emptyPackageFacts(), rawText: "" };
+    throw error;
   }
 }
 
@@ -259,9 +734,9 @@ function operationsFromBody(text, maskedBody, bodyOffset, filePath) {
     sourceLine: lineOf(text, bodyOffset + (m.index ?? 0))
   }));
 }
-async function parseCdsFile(repoPath, filePath) {
+async function parseCdsFile(repoPath, filePath, context) {
   const absolute = path4.join(repoPath, filePath);
-  const text = await fs3.readFile(absolute, "utf8");
+  const text = context?.get(filePath)?.text ?? await fs3.readFile(absolute, "utf8");
   const masked = maskCommentsAndStrings(text);
   const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
   const services = [];
@@ -311,8 +786,8 @@ async function parseCdsFile(repoPath, filePath) {
 }
 
 // src/parsers/decorator-parser.ts
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs5 from "fs/promises";
+import path6 from "path";
 import ts2 from "typescript";
 
 // src/linker/operation-decorator-normalizer.ts
@@ -356,7 +831,34 @@ function normalizeDecoratorOperationSignal(value, raw, candidateOperation) {
 }
 
 // src/parsers/ts-project.ts
+import fs4 from "fs/promises";
+import path5 from "path";
 import ts from "typescript";
+async function loadRepositorySourceContext(repoPath, filePaths, instrumentation) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const inputPath of filePaths) {
+    const filePath = normalizePath(inputPath);
+    await instrumentation?.onSourceRead?.(repoPath, filePath);
+    const text = await fs4.readFile(path5.join(repoPath, filePath), "utf8");
+    let ast;
+    snapshots.set(filePath, {
+      repoPath,
+      filePath,
+      text,
+      sizeBytes: Buffer.byteLength(text),
+      sourceFile: () => {
+        if (ast) return ast;
+        instrumentation?.onAstCreated?.(repoPath, filePath);
+        ast = createSourceFile(filePath, text);
+        return ast;
+      }
+    });
+  }
+  return {
+    get: (filePath) => snapshots.get(normalizePath(filePath)),
+    entries: () => [...snapshots.values()]
+  };
+}
 function createSourceFile(filePath, text) {
   return ts.createSourceFile(
     filePath,
@@ -368,6 +870,22 @@ function createSourceFile(filePath, text) {
 }
 
 // src/parsers/decorator-parser.ts
+var OPERATION_DECORATORS = /* @__PURE__ */ new Set(["Action", "Func", "On"]);
+var EVENT_DECORATORS = /* @__PURE__ */ new Set(["Event"]);
+var LIFECYCLE_DECORATORS = /* @__PURE__ */ new Map([
+  ["BeforeCreate", { phase: "before", event: "CREATE" }],
+  ["OnCreate", { phase: "on", event: "CREATE" }],
+  ["AfterCreate", { phase: "after", event: "CREATE" }],
+  ["BeforeRead", { phase: "before", event: "READ" }],
+  ["OnRead", { phase: "on", event: "READ" }],
+  ["AfterRead", { phase: "after", event: "READ" }],
+  ["BeforeUpdate", { phase: "before", event: "UPDATE" }],
+  ["OnUpdate", { phase: "on", event: "UPDATE" }],
+  ["AfterUpdate", { phase: "after", event: "UPDATE" }],
+  ["BeforeDelete", { phase: "before", event: "DELETE" }],
+  ["OnDelete", { phase: "on", event: "DELETE" }],
+  ["AfterDelete", { phase: "after", event: "DELETE" }]
+]);
 function line(sf, pos) {
   return sf.getLineAndCharacterOfPosition(pos).line + 1;
 }
@@ -382,6 +900,12 @@ function firstArg(d) {
   const e = d.expression;
   return ts2.isCallExpression(e) ? e.arguments[0] : void 0;
 }
+function decoratorArguments(d) {
+  return ts2.isCallExpression(d.expression) ? d.expression.arguments : void 0;
+}
+function methodName(name) {
+  return ts2.isIdentifier(name) || ts2.isStringLiteralLike(name) || ts2.isNumericLiteral(name) ? name.text : name.getText();
+}
 function unwrapExpression(expression) {
   let current = expression;
   while (ts2.isParenthesizedExpression(current) || ts2.isAsExpression(current) || ts2.isTypeAssertionExpression(current) || ts2.isSatisfiesExpression(current)) current = current.expression;
@@ -419,9 +943,12 @@ function collectStringLookups(source) {
   const lookups = {
     identifiers: /* @__PURE__ */ new Map(),
     enumMembers: /* @__PURE__ */ new Map(),
-    objectProperties: /* @__PURE__ */ new Map()
+    objectProperties: /* @__PURE__ */ new Map(),
+    capDecoratorNames: /* @__PURE__ */ new Map(),
+    capDecoratorNamespaces: /* @__PURE__ */ new Set()
   };
   for (const statement of source.statements) {
+    collectCapDecoratorImports(statement, lookups);
     if (ts2.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
     if (!ts2.isVariableStatement(statement) || !(statement.declarationList.flags & ts2.NodeFlags.Const)) continue;
     for (const declaration of statement.declarationList.declarations) {
@@ -433,75 +960,277 @@ function collectStringLookups(source) {
   }
   return lookups;
 }
-function unresolved(rawExpression, reason) {
-  return { rawExpression, resolutionKind: "unresolved", unresolvedReason: reason };
+function collectCapDecoratorImports(statement, lookups) {
+  if (!ts2.isImportDeclaration(statement) || !ts2.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "cds-routing-handlers") return;
+  const clause = statement.importClause;
+  if (!clause || clause.isTypeOnly) return;
+  const bindings = clause.namedBindings;
+  if (bindings && ts2.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      if (element.isTypeOnly) continue;
+      lookups.capDecoratorNames.set(
+        element.name.text,
+        element.propertyName?.text ?? element.name.text
+      );
+    }
+  }
+  if (bindings && ts2.isNamespaceImport(bindings))
+    lookups.capDecoratorNamespaces.add(bindings.name.text);
+}
+function capDecoratorName(decorator, lookups) {
+  const expression = ts2.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
+  if (ts2.isIdentifier(expression))
+    return lookups.capDecoratorNames.get(expression.text);
+  if (ts2.isPropertyAccessExpression(expression) && ts2.isIdentifier(expression.expression) && lookups.capDecoratorNamespaces.has(expression.expression.text))
+    return expression.name.text;
+  return void 0;
+}
+function unresolved(rawExpression, reason, argumentExpression) {
+  return {
+    rawExpression,
+    argumentExpression,
+    resolutionKind: "unresolved",
+    unresolvedReason: reason
+  };
+}
+function resolved2(rawExpression, argumentExpression, resolvedValue, resolutionKind) {
+  return { rawExpression, argumentExpression, resolvedValue, resolutionKind };
 }
 function generatedConstant(rawExpression) {
   const match = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/.exec(rawExpression.trim());
   return match?.[1] ? generatedOperationNameFromConstant(match[1]) : void 0;
 }
-function resolveDecoratorArgument(argument, lookups) {
-  if (!argument) return unresolved("", "decorator_argument_missing");
-  const rawExpression = argument.getText();
+function resolveDecoratorArgument(argument, lookups, rawExpression) {
+  if (!argument) return unresolved(rawExpression, "decorator_argument_missing");
+  const argumentExpression = argument.getText();
   const expression = unwrapExpression(argument);
   if (ts2.isStringLiteralLike(expression))
-    return { rawExpression, resolvedValue: expression.text, resolutionKind: "literal" };
+    return resolved2(rawExpression, argumentExpression, expression.text, "literal");
   if (ts2.isIdentifier(expression)) {
     const value = lookups.identifiers.get(expression.text);
-    return value === void 0 ? unresolved(rawExpression, "identifier_not_resolved_to_local_const_string") : { rawExpression, resolvedValue: value, resolutionKind: "const_identifier" };
+    return value === void 0 ? unresolved(rawExpression, "identifier_not_resolved_to_local_const_string", argumentExpression) : resolved2(rawExpression, argumentExpression, value, "const_identifier");
   }
   if (ts2.isPropertyAccessExpression(expression) && ts2.isIdentifier(expression.expression)) {
     const key = `${expression.expression.text}.${expression.name.text}`;
     const enumValue = lookups.enumMembers.get(key);
     if (enumValue !== void 0)
-      return { rawExpression, resolvedValue: enumValue, resolutionKind: "enum_member" };
+      return resolved2(rawExpression, argumentExpression, enumValue, "enum_member");
     const objectValue2 = lookups.objectProperties.get(key);
     if (objectValue2 !== void 0)
-      return { rawExpression, resolvedValue: objectValue2, resolutionKind: "const_object_property" };
+      return resolved2(rawExpression, argumentExpression, objectValue2, "const_object_property");
   }
-  const generatedValue = generatedConstant(rawExpression);
+  const generatedValue = generatedConstant(argumentExpression);
   if (generatedValue !== void 0)
-    return {
+    return resolved2(
       rawExpression,
-      resolvedValue: generatedValue,
-      resolutionKind: "generated_constant_name"
-    };
+      argumentExpression,
+      generatedValue,
+      "generated_constant_name"
+    );
   if (ts2.isPropertyAccessExpression(expression))
-    return unresolved(rawExpression, "property_access_not_resolved_to_local_string");
-  return unresolved(rawExpression, "unsupported_decorator_expression");
+    return unresolved(
+      rawExpression,
+      "property_access_not_resolved_to_local_string",
+      argumentExpression
+    );
+  return unresolved(rawExpression, "unsupported_decorator_expression", argumentExpression);
+}
+function classificationFor(name) {
+  if (OPERATION_DECORATORS.has(name))
+    return { handlerKind: "operation", executable: true };
+  if (EVENT_DECORATORS.has(name))
+    return { handlerKind: "event", executable: true };
+  const lifecycle = LIFECYCLE_DECORATORS.get(name);
+  if (!lifecycle) return void 0;
+  return {
+    handlerKind: "entity_lifecycle",
+    executable: true,
+    lifecyclePhase: lifecycle.phase,
+    lifecycleEvent: lifecycle.event
+  };
+}
+function lifecycleLikePhase(name) {
+  if (/^On[A-Z]/.test(name)) return "on";
+  if (/^Before[A-Z]/.test(name)) return "before";
+  if (/^After[A-Z]/.test(name)) return "after";
+  return void 0;
+}
+function withClassification(resolution, classification) {
+  return {
+    ...resolution,
+    handlerKind: classification.handlerKind,
+    executable: classification.executable,
+    lifecyclePhase: classification.lifecyclePhase,
+    lifecycleEvent: classification.lifecycleEvent
+  };
+}
+function withDecoratorEvidence(resolution, decorator, resolvedDecoratorKind) {
+  return {
+    ...resolution,
+    decoratorExpression: decorator.expression.getText(),
+    resolvedDecoratorKind,
+    decoratorImportSource: resolvedDecoratorKind ? "cds-routing-handlers" : void 0
+  };
+}
+function lifecycleDecoratorResolution(decorator, lookups, classification) {
+  const rawExpression = decorator.expression.getText();
+  const args = decoratorArguments(decorator);
+  if (args?.length === 0)
+    return {
+      classification,
+      resolution: withClassification({
+        rawExpression,
+        resolutionKind: "lifecycle_implicit"
+      }, classification)
+    };
+  const resolution = args?.length === 1 ? resolveDecoratorArgument(args[0], lookups, rawExpression) : unresolved(rawExpression, args ? "unsupported_lifecycle_argument_count" : "lifecycle_decorator_call_required");
+  const unsupported = { ...classification, handlerKind: "unsupported_lifecycle", executable: false };
+  const unsupportedResolution = args?.length === 1 ? { ...resolution, unresolvedReason: "lifecycle_decorator_arguments_not_supported" } : resolution;
+  return {
+    classification: unsupported,
+    resolution: withClassification(unsupportedResolution, unsupported)
+  };
 }
-async function parseDecorators(repoPath, filePath) {
-  const text = await fs4.readFile(path5.join(repoPath, filePath), "utf8");
-  const sf = createSourceFile(filePath, text);
+function unsupportedLifecycleResolution(decorator, phase) {
+  const classification = {
+    handlerKind: "unsupported_lifecycle",
+    executable: false,
+    lifecyclePhase: phase
+  };
+  const resolution = unresolved(
+    decorator.expression.getText(),
+    "lifecycle_decorator_not_allowlisted"
+  );
+  return { classification, resolution: withClassification(resolution, classification) };
+}
+function unsupportedDecoratorResolution(decorator, reason, phase) {
+  const classification = {
+    handlerKind: phase ? "unsupported_lifecycle" : "unsupported_decorator",
+    executable: false,
+    lifecyclePhase: phase
+  };
+  return {
+    classification,
+    resolution: withClassification(
+      unresolved(decorator.expression.getText(), reason),
+      classification
+    )
+  };
+}
+function parseMethodDecorator(decorator, lookups, handlerClass, allowLifecycle) {
+  const decoratorKind = callName(decorator);
+  const importedKind = capDecoratorName(decorator, lookups);
+  const resolvedKind = importedKind ?? decoratorKind;
+  const base = classificationFor(resolvedKind);
+  const phase = lifecycleLikePhase(resolvedKind);
+  const isLifecycle = base?.handlerKind === "entity_lifecycle" || Boolean(phase && !base);
+  if (!handlerClass && isLifecycle) return void 0;
+  const parsed = isLifecycle && (!allowLifecycle || !importedKind) ? unsupportedDecoratorResolution(
+    decorator,
+    "lifecycle_decorator_import_not_supported",
+    phase
+  ) : base?.handlerKind === "entity_lifecycle" ? lifecycleDecoratorResolution(decorator, lookups, base) : phase && !base ? unsupportedLifecycleResolution(decorator, phase) : !base && handlerClass ? unsupportedDecoratorResolution(decorator, "decorator_not_allowlisted") : {
+    classification: base,
+    resolution: resolveDecoratorArgument(
+      firstArg(decorator),
+      lookups,
+      firstArg(decorator)?.getText() ?? decorator.expression.getText()
+    )
+  };
+  if (!parsed.classification) return void 0;
+  return {
+    classification: parsed.classification,
+    resolution: parsed.resolution,
+    decoratorKind,
+    importedKind
+  };
+}
+function methodDecoratorFact(method, decorator, lookups, source, filePath, handlerClass, allowLifecycle) {
+  const parsed = parseMethodDecorator(decorator, lookups, handlerClass, allowLifecycle);
+  if (!parsed) return void 0;
+  const classification = method.body ? parsed.classification : { ...parsed.classification, executable: false };
+  const resolution = method.body ? parsed.resolution : { ...parsed.resolution, unresolvedReason: "handler_method_body_missing" };
+  const argumentExpression = firstArg(decorator)?.getText();
+  return {
+    methodName: methodName(method.name),
+    decoratorKind: parsed.decoratorKind,
+    decoratorValue: parsed.resolution.resolvedValue,
+    decoratorRawExpression: argumentExpression ?? decorator.expression.getText(),
+    handlerKind: classification.handlerKind,
+    executable: classification.executable,
+    lifecyclePhase: classification.lifecyclePhase,
+    lifecycleEvent: classification.lifecycleEvent,
+    decoratorResolution: withDecoratorEvidence(
+      withClassification(resolution, classification),
+      decorator,
+      parsed.importedKind
+    ),
+    sourceFile: normalizePath(filePath),
+    sourceLine: line(source, method.getStart())
+  };
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function parseClassMethods(node, lookups, source, filePath, handlerClass, allowLifecycle) {
+  const methods = [];
+  const observed = [];
+  const unsupported = [];
+  for (const method of node.members.filter(ts2.isMethodDeclaration)) {
+    for (const decorator of decs(method)) {
+      observed.push(callName(decorator));
+      const fact = methodDecoratorFact(
+        method,
+        decorator,
+        lookups,
+        source,
+        filePath,
+        handlerClass,
+        allowLifecycle
+      );
+      if (fact) methods.push(fact);
+      if (!fact?.executable) unsupported.push(callName(decorator));
+    }
+  }
+  return {
+    methods,
+    observedDecoratorNames: unique(observed),
+    unsupportedDecoratorNames: unique(unsupported)
+  };
+}
+function parseHandlerClass(node, lookups, source, filePath) {
+  const classDecoratorNames = unique(decs(node).map(callName));
+  const classDecorators = decs(node);
+  const hasImportedHandler = classDecorators.some((decorator) => capDecoratorName(decorator, lookups) === "Handler");
+  const hasHandlerDecorator = hasImportedHandler || classDecoratorNames.includes("Handler");
+  const parsed = parseClassMethods(
+    node,
+    lookups,
+    source,
+    filePath,
+    hasHandlerDecorator,
+    hasImportedHandler
+  );
+  if (!hasHandlerDecorator && parsed.methods.length === 0) return void 0;
+  return {
+    className: node.name?.text ?? "AnonymousHandler",
+    sourceFile: normalizePath(filePath),
+    sourceLine: line(source, node.getStart()),
+    ...parsed,
+    hasHandlerDecorator,
+    classDecoratorNames
+  };
+}
+async function parseDecorators(repoPath, filePath, context) {
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text ?? await fs5.readFile(path6.join(repoPath, filePath), "utf8");
+  const sf = snapshot?.sourceFile() ?? createSourceFile(filePath, text);
   const lookups = collectStringLookups(sf);
   const handlers = [];
   function visit(node) {
     if (ts2.isClassDeclaration(node)) {
-      const className = node.name?.text ?? "AnonymousHandler";
-      const hasHandler = decs(node).some((d) => callName(d) === "Handler");
-      const methods = node.members.filter(ts2.isMethodDeclaration).flatMap(
-        (m) => decs(m).filter(
-          (d) => ["Func", "Action", "On", "Event"].includes(callName(d))
-        ).map((d) => {
-          const decoratorResolution = resolveDecoratorArgument(firstArg(d), lookups);
-          return {
-            methodName: m.name.getText(),
-            decoratorKind: callName(d),
-            decoratorValue: decoratorResolution.resolvedValue,
-            decoratorRawExpression: decoratorResolution.rawExpression,
-            decoratorResolution,
-            sourceFile: normalizePath(filePath),
-            sourceLine: line(sf, m.getStart())
-          };
-        })
-      );
-      if (hasHandler || methods.length > 0)
-        handlers.push({
-          className,
-          sourceFile: normalizePath(filePath),
-          sourceLine: line(sf, node.getStart()),
-          methods
-        });
+      const handler = parseHandlerClass(node, lookups, sf, filePath);
+      if (handler) handlers.push(handler);
     }
     ts2.forEachChild(node, visit);
   }
@@ -511,8 +1240,8 @@ async function parseDecorators(repoPath, filePath) {
 
 // src/parsers/handler-registration-parser.ts
 import fsSync from "fs";
-import fs5 from "fs/promises";
-import path6 from "path";
+import fs6 from "fs/promises";
+import path7 from "path";
 import ts3 from "typescript";
 var MAX_EXPORT_DEPTH = 5;
 function lineOf2(sourceFile, node) {
@@ -529,15 +1258,37 @@ function importSourceFor(identifier, imports) {
   const evidence = imports.get(identifier);
   return evidence ? `${evidence.source}#${evidence.importedName}` : void 0;
 }
-async function parseHandlerRegistrations(repoPath, filePath) {
-  const absolutePath = path6.join(repoPath, filePath);
-  const text = await fs5.readFile(absolutePath, "utf8");
-  const sourceFile = ts3.createSourceFile(filePath, text, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+async function parseHandlerRegistrations(repoPath, filePath, context) {
+  const absolutePath = path7.join(repoPath, filePath);
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text ?? await fs6.readFile(absolutePath, "utf8");
+  const sourceFile = snapshot?.sourceFile() ?? ts3.createSourceFile(
+    filePath,
+    text,
+    ts3.ScriptTarget.Latest,
+    true,
+    ts3.ScriptKind.TS
+  );
   const imports = collectImports(sourceFile);
-  const localArrays = collectLocalArrays(sourceFile, imports, /* @__PURE__ */ new Map(), repoPath, filePath);
+  const localArrays = collectLocalArrays(
+    sourceFile,
+    imports,
+    /* @__PURE__ */ new Map(),
+    repoPath,
+    filePath,
+    context
+  );
   const out = [];
   function emitFromExpression(expression, call) {
-    const classes = resolveArrayExpression(expression, localArrays, imports, repoPath, filePath, /* @__PURE__ */ new Set());
+    const classes = resolveArrayExpression(
+      expression,
+      localArrays,
+      imports,
+      repoPath,
+      filePath,
+      /* @__PURE__ */ new Set(),
+      context
+    );
     for (const cls of classes) {
       out.push({
         className: cls.className,
@@ -598,70 +1349,86 @@ function collectImports(sourceFile) {
   }
   return imports;
 }
-function collectLocalArrays(sourceFile, imports, seed, repoPath = "", fromFile = "") {
+function collectLocalArrays(sourceFile, imports, seed, repoPath = "", fromFile = "", context) {
   const arrays = new Map(seed);
   for (const statement of sourceFile.statements) {
     if (ts3.isVariableStatement(statement)) {
       for (const decl of statement.declarationList.declarations) {
         if (ts3.isIdentifier(decl.name) && decl.initializer && ts3.isArrayLiteralExpression(decl.initializer)) {
-          arrays.set(decl.name.text, resolveArrayLiteral(decl.initializer, arrays, imports, repoPath, fromFile, /* @__PURE__ */ new Set()));
+          arrays.set(decl.name.text, resolveArrayLiteral(
+            decl.initializer,
+            arrays,
+            imports,
+            repoPath,
+            fromFile,
+            /* @__PURE__ */ new Set(),
+            context
+          ));
         }
       }
     }
   }
   return arrays;
 }
-function resolveArrayExpression(expr, arrays, imports, repoPath, fromFile, seen) {
-  if (ts3.isArrayLiteralExpression(expr)) return resolveArrayLiteral(expr, arrays, imports, repoPath, fromFile, seen);
+function resolveArrayExpression(expr, arrays, imports, repoPath, fromFile, seen, context) {
+  if (ts3.isArrayLiteralExpression(expr)) return resolveArrayLiteral(expr, arrays, imports, repoPath, fromFile, seen, context);
   if (ts3.isIdentifier(expr)) {
     const local = arrays.get(expr.text);
     if (local) return local;
     const evidence = imports.get(expr.text);
-    if (evidence && isRelative(evidence.source)) return resolveImportedArray(repoPath, fromFile, evidence, seen);
+    if (evidence && isRelative(evidence.source)) return resolveImportedArray(repoPath, fromFile, evidence, seen, context);
     if (evidence) return [{ className: evidence.importedName === "default" ? expr.text : evidence.importedName, importSource: `${evidence.source}#${evidence.importedName}` }];
   }
   return [];
 }
-function resolveArrayLiteral(array, arrays, imports, repoPath, fromFile, seen) {
+function resolveArrayLiteral(array, arrays, imports, repoPath, fromFile, seen, context) {
   const out = [];
   for (const element of array.elements) {
-    if (ts3.isSpreadElement(element)) out.push(...resolveArrayExpression(element.expression, arrays, imports, repoPath, fromFile, seen));
+    if (ts3.isSpreadElement(element)) out.push(...resolveArrayExpression(element.expression, arrays, imports, repoPath, fromFile, seen, context));
     else if (ts3.isIdentifier(element)) out.push({ className: element.text, importSource: importSourceFor(element.text, imports) });
   }
   return out;
 }
-function resolveImportedArray(repoPath, fromFile, evidence, seen) {
+function resolveImportedArray(repoPath, fromFile, evidence, seen, context) {
   const moduleFile = resolveRelativeModule(repoPath, fromFile, evidence.source);
   if (!moduleFile) return [];
   const key = `${moduleFile}:${evidence.importedName}`;
   if (seen.has(key) || seen.size > MAX_EXPORT_DEPTH) return [];
   seen.add(key);
-  const exports = readExports(repoPath, moduleFile, seen);
+  const exports = readExports(repoPath, moduleFile, seen, context);
   if (evidence.importedName === "default") return exports.defaultArray ?? [];
   return exports.arrays.get(evidence.importedName) ?? exports.arrays.get(exports.aliases.get(evidence.importedName) ?? evidence.importedName) ?? [];
 }
 function resolveRelativeModule(repoPath, fromFile, specifier) {
-  const base = path6.resolve(repoPath, path6.dirname(fromFile), specifier);
-  for (const candidate of [base, `${base}.ts`, `${base}.js`, path6.join(base, "index.ts"), path6.join(base, "index.js")]) {
+  const base = path7.resolve(repoPath, path7.dirname(fromFile), specifier);
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path7.join(base, "index.ts"), path7.join(base, "index.js")]) {
     try {
       const stat = fsSync.statSync(candidate);
-      if (stat.isFile()) return normalizePath(path6.relative(repoPath, candidate));
+      if (stat.isFile()) return normalizePath(path7.relative(repoPath, candidate));
     } catch {
     }
   }
   return void 0;
 }
-function readExports(repoPath, filePath, seen) {
-  const absolute = path6.join(repoPath, filePath);
+function readExports(repoPath, filePath, seen, context) {
+  const absolute = path7.join(repoPath, filePath);
   let text;
+  const snapshot = context?.get(filePath);
   try {
-    text = fsSync.readFileSync(absolute, "utf8");
+    text = snapshot?.text ?? fsSync.readFileSync(absolute, "utf8");
   } catch {
     return { arrays: /* @__PURE__ */ new Map(), aliases: /* @__PURE__ */ new Map() };
   }
-  const sourceFile = ts3.createSourceFile(filePath, text, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+  const sourceFile = snapshot?.sourceFile() ?? ts3.createSourceFile(filePath, text, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
   const imports = collectImports(sourceFile);
-  const arrays = collectLocalArrays(sourceFile, imports, /* @__PURE__ */ new Map(), repoPath, filePath);
+  const arrays = collectLocalArrays(
+    sourceFile,
+    imports,
+    /* @__PURE__ */ new Map(),
+    repoPath,
+    filePath,
+    context
+  );
   const aliases = /* @__PURE__ */ new Map();
   let defaultArray;
   for (const statement of sourceFile.statements) {
@@ -672,7 +1439,13 @@ function readExports(repoPath, filePath, seen) {
         const local = element.propertyName?.text ?? element.name.text;
         aliases.set(element.name.text, local);
         if (module && isRelative(module)) {
-          const imported = resolveImportedArray(repoPath, filePath, { source: module, importedName: local }, seen);
+          const imported = resolveImportedArray(
+            repoPath,
+            filePath,
+            { source: module, importedName: local },
+            seen,
+            context
+          );
           if (imported.length > 0) arrays.set(element.name.text, imported);
         }
       }
@@ -704,12 +1477,12 @@ function summarizeExpression(text) {
 }
 
 // src/parsers/service-binding-parser.ts
-import path8 from "path";
+import path9 from "path";
 import ts5 from "typescript";
 
 // src/parsers/service-binding-parser-helpers.ts
-import fs6 from "fs/promises";
-import path7 from "path";
+import fs7 from "fs/promises";
+import path8 from "path";
 import ts4 from "typescript";
 function lineOf3(sf, node) {
   return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
@@ -795,9 +1568,11 @@ function findConnectInExpression(expr) {
   visit(expr);
   return found;
 }
-async function readSource(abs) {
+async function readSource(abs, context, filePath) {
+  const snapshot = filePath ? context?.get(filePath) : void 0;
+  if (snapshot) return snapshot.sourceFile();
   try {
-    const text = await fs6.readFile(abs, "utf8");
+    const text = await fs7.readFile(abs, "utf8");
     return ts4.createSourceFile(abs, text, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
   } catch {
     return void 0;
@@ -805,12 +1580,12 @@ async function readSource(abs) {
 }
 async function resolveImport(repoPath, fromFile, spec) {
   if (!spec.startsWith(".")) return void 0;
-  const rawBase = path7.resolve(repoPath, path7.dirname(fromFile), spec);
-  const parsed = path7.parse(rawBase);
-  const base = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(parsed.ext) ? path7.join(parsed.dir, parsed.name) : rawBase;
-  for (const candidate of [base, `${base}.ts`, `${base}.js`, path7.join(base, "index.ts"), path7.join(base, "index.js")]) {
-    const stat = await fs6.stat(candidate).catch(() => void 0);
-    if (stat?.isFile()) return normalizePath(path7.relative(repoPath, candidate));
+  const rawBase = path8.resolve(repoPath, path8.dirname(fromFile), spec);
+  const parsed = path8.parse(rawBase);
+  const base = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"].includes(parsed.ext) ? path8.join(parsed.dir, parsed.name) : rawBase;
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path8.join(base, "index.ts"), path8.join(base, "index.js")]) {
+    const stat = await fs7.stat(candidate).catch(() => void 0);
+    if (stat?.isFile()) return normalizePath(path8.relative(repoPath, candidate));
   }
   return void 0;
 }
@@ -918,8 +1693,8 @@ function exportedLocalNames(sf) {
   }
   return exports;
 }
-async function helperBindings(repoPath, filePath) {
-  const sf = await readSource(path8.join(repoPath, filePath));
+async function helperBindings(repoPath, filePath, context) {
+  const sf = await readSource(path9.join(repoPath, filePath), context, filePath);
   if (!sf) return [];
   const sourceFileAst = sf;
   const out = [];
@@ -979,8 +1754,8 @@ async function helperBindings(repoPath, filePath) {
   }
   return out;
 }
-async function parseServiceBindings(repoPath, filePath) {
-  const sf = await readSource(path8.join(repoPath, filePath));
+async function parseServiceBindings(repoPath, filePath, context) {
+  const sf = await readSource(path9.join(repoPath, filePath), context, filePath);
   if (!sf) return [];
   const sourceFileAst = sf;
   const out = [];
@@ -1019,7 +1794,7 @@ async function parseServiceBindings(repoPath, filePath) {
     if (!helperCache.has(imp.sourceFile))
       helperCache.set(
         imp.sourceFile,
-        await helperBindings(repoPath, imp.sourceFile)
+        await helperBindings(repoPath, imp.sourceFile, context)
       );
     return (helperCache.get(imp.sourceFile) ?? []).filter((h) => h.exportedName === imp.exportedName).map((helper) => ({ imp, helper }));
   }
@@ -1069,28 +1844,28 @@ async function parseServiceBindings(repoPath, filePath) {
       });
     else if (ts5.isIdentifier(call.expression)) {
       const localDirect = localDirectHelpers.get(call.expression.text);
-      const resolved2 = localDirect ? { helper: localDirect, imp: void 0 } : await importedHelper(call.expression.text);
-      if (resolved2)
+      const resolved3 = localDirect ? { helper: localDirect, imp: void 0 } : await importedHelper(call.expression.text);
+      if (resolved3)
         out.push({
           variableName: targetName,
-          alias: resolved2.helper.alias,
-          aliasExpr: resolved2.helper.aliasExpr,
-          destinationExpr: resolved2.helper.destinationExpr,
-          servicePathExpr: resolved2.helper.servicePathExpr,
-          isDynamic: resolved2.helper.isDynamic,
-          placeholders: resolved2.helper.placeholders,
+          alias: resolved3.helper.alias,
+          aliasExpr: resolved3.helper.aliasExpr,
+          destinationExpr: resolved3.helper.destinationExpr,
+          servicePathExpr: resolved3.helper.servicePathExpr,
+          isDynamic: resolved3.helper.isDynamic,
+          placeholders: resolved3.helper.placeholders,
           sourceFile: normalizePath(filePath),
           sourceLine: lineOf3(sourceFileAst, node),
           helperChain: [
-            ...resolved2.helper.helperChain ?? [],
+            ...resolved3.helper.helperChain ?? [],
             {
               callerVariable: targetName,
               ...aliasKind === "assignment" ? { assignedFrom: call.expression.text, aliasKind, scopeRule: "same-file-source-order" } : {},
               importedHelper: call.expression.text,
-              importSource: resolved2.imp?.sourceFile,
-              exportedSymbol: resolved2.imp?.exportedName ?? resolved2.helper.exportedName,
-              helperSourceFile: resolved2.helper.sourceFile,
-              helperSourceLine: resolved2.helper.sourceLine
+              importSource: resolved3.imp?.sourceFile,
+              exportedSymbol: resolved3.imp?.exportedName ?? resolved3.helper.exportedName,
+              helperSourceFile: resolved3.helper.sourceFile,
+              helperSourceLine: resolved3.helper.sourceLine
             }
           ]
         });
@@ -1119,28 +1894,28 @@ async function parseServiceBindings(repoPath, filePath) {
     const helpers = objectHelperVariables.get(unwrapped.expression.text) ?? [];
     const matches2 = helpers.filter((row) => row.helper.returnedProperty === unwrapped.name.text);
     if (matches2.length !== 1) return false;
-    const resolved2 = matches2[0];
+    const resolved3 = matches2[0];
     out.push({
       variableName: targetName,
-      alias: resolved2.helper.alias,
-      aliasExpr: resolved2.helper.aliasExpr,
-      destinationExpr: resolved2.helper.destinationExpr,
-      servicePathExpr: resolved2.helper.servicePathExpr,
-      isDynamic: resolved2.helper.isDynamic,
-      placeholders: resolved2.helper.placeholders,
+      alias: resolved3.helper.alias,
+      aliasExpr: resolved3.helper.aliasExpr,
+      destinationExpr: resolved3.helper.destinationExpr,
+      servicePathExpr: resolved3.helper.servicePathExpr,
+      isDynamic: resolved3.helper.isDynamic,
+      placeholders: resolved3.helper.placeholders,
       sourceFile: normalizePath(filePath),
       sourceLine: lineOf3(sourceFileAst, node),
       helperChain: [
-        ...resolved2.helper.helperChain ?? [],
+        ...resolved3.helper.helperChain ?? [],
         {
           callerVariable: targetName,
           sourceVariable: unwrapped.expression.text,
           returnedProperty: unwrapped.name.text,
           assignedFromProperty: unwrapped.getText(sourceFileAst),
-          importSource: resolved2.imp?.sourceFile,
-          exportedSymbol: resolved2.imp?.exportedName,
-          helperSourceFile: resolved2.helper.sourceFile,
-          helperSourceLine: resolved2.helper.sourceLine
+          importSource: resolved3.imp?.sourceFile,
+          exportedSymbol: resolved3.imp?.exportedName,
+          helperSourceFile: resolved3.helper.sourceFile,
+          helperSourceLine: resolved3.helper.sourceLine
         }
       ]
     });
@@ -1157,18 +1932,18 @@ async function parseServiceBindings(repoPath, filePath) {
       const propertyName3 = el.propertyName && ts5.isIdentifier(el.propertyName) ? el.propertyName.text : el.name.text;
       const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName3);
       if (matches2.length !== 1) continue;
-      const resolved2 = matches2[0];
+      const resolved3 = matches2[0];
       out.push({
         variableName: el.name.text,
-        alias: resolved2.helper.alias,
-        aliasExpr: resolved2.helper.aliasExpr,
-        destinationExpr: resolved2.helper.destinationExpr,
-        servicePathExpr: resolved2.helper.servicePathExpr,
-        isDynamic: resolved2.helper.isDynamic,
-        placeholders: resolved2.helper.placeholders,
+        alias: resolved3.helper.alias,
+        aliasExpr: resolved3.helper.aliasExpr,
+        destinationExpr: resolved3.helper.destinationExpr,
+        servicePathExpr: resolved3.helper.servicePathExpr,
+        isDynamic: resolved3.helper.isDynamic,
+        placeholders: resolved3.helper.placeholders,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf3(sourceFileAst, decl),
-        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: el.name.text, helperFunction: call.expression.getText(sourceFileAst), returnedProperty: propertyName3, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
+        helperChain: [...resolved3.helper.helperChain ?? [], { callerVariable: el.name.text, helperFunction: call.expression.getText(sourceFileAst), returnedProperty: propertyName3, importSource: resolved3.imp?.sourceFile, exportedSymbol: resolved3.imp?.exportedName, helperSourceFile: resolved3.helper.sourceFile, helperSourceLine: resolved3.helper.sourceLine }]
       });
     }
   }
@@ -1190,18 +1965,18 @@ async function parseServiceBindings(repoPath, filePath) {
       if (!propertyName3 || !targetName) continue;
       const matches2 = helpers.filter((row) => row.helper.returnedProperty === propertyName3);
       if (matches2.length !== 1) continue;
-      const resolved2 = matches2[0];
+      const resolved3 = matches2[0];
       out.push({
         variableName: targetName,
-        alias: resolved2.helper.alias,
-        aliasExpr: resolved2.helper.aliasExpr,
-        destinationExpr: resolved2.helper.destinationExpr,
-        servicePathExpr: resolved2.helper.servicePathExpr,
-        isDynamic: resolved2.helper.isDynamic,
-        placeholders: resolved2.helper.placeholders,
+        alias: resolved3.helper.alias,
+        aliasExpr: resolved3.helper.aliasExpr,
+        destinationExpr: resolved3.helper.destinationExpr,
+        servicePathExpr: resolved3.helper.servicePathExpr,
+        isDynamic: resolved3.helper.isDynamic,
+        placeholders: resolved3.helper.placeholders,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf3(sourceFileAst, node),
-        helperChain: [...resolved2.helper.helperChain ?? [], { callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName3, importSource: resolved2.imp?.sourceFile, exportedSymbol: resolved2.imp?.exportedName, helperSourceFile: resolved2.helper.sourceFile, helperSourceLine: resolved2.helper.sourceLine }]
+        helperChain: [...resolved3.helper.helperChain ?? [], { callerVariable: targetName, assignedFrom: call.expression.getText(sourceFileAst), aliasKind: "assignment", scopeRule: "same-file-source-order", returnedProperty: propertyName3, importSource: resolved3.imp?.sourceFile, exportedSymbol: resolved3.imp?.exportedName, helperSourceFile: resolved3.helper.sourceFile, helperSourceLine: resolved3.helper.sourceLine }]
       });
     }
   }
@@ -1400,8 +2175,8 @@ function collectClassHelpers(sf) {
 }
 
 // src/parsers/outbound-call-parser.ts
-import fs7 from "fs/promises";
-import path10 from "path";
+import fs8 from "fs/promises";
+import path11 from "path";
 import ts8 from "typescript";
 
 // src/linker/external-http-target.ts
@@ -1419,8 +2194,8 @@ function redactUrl(value) {
     url.username = "";
     url.password = "";
     for (const key of [...url.searchParams.keys()]) url.searchParams.set(key, sensitiveKeys.has(key.toLowerCase()) ? "<redacted>" : "<redacted>");
-    const path11 = `${url.pathname}${url.search ? url.search : ""}`;
-    return value.startsWith("/") ? path11 : `${url.origin}${path11}`;
+    const path12 = `${url.pathname}${url.search ? url.search : ""}`;
+    return value.startsWith("/") ? path12 : `${url.origin}${path12}`;
   } catch {
     return value.replace(/([?&][^=;&]*(?:token|key|password|secret|cookie|authorization)[^=;&]*=)[^&]*/gi, "$1<redacted>");
   }
@@ -1454,9 +2229,9 @@ function safeParse(value) {
 }
 
 // src/linker/odata-path-normalizer.ts
-function normalizeODataOperationInvocationPath(path11) {
-  if (path11 === void 0) return void 0;
-  const raw = path11.trim();
+function normalizeODataOperationInvocationPath(path12) {
+  if (path12 === void 0) return void 0;
+  const raw = path12.trim();
   if (!raw) return void 0;
   const rejected = (reason) => ({ rawOperationPath: raw, normalizedOperationPath: raw, wasInvocation: false, invocationArgumentPlaceholderKeys: [], normalizationRejectedReason: reason });
   const open = raw.indexOf("(");
@@ -1479,8 +2254,8 @@ function normalizeODataOperationInvocationPath(path11) {
     normalizationReason: "balanced_top_level_operation_invocation"
   };
 }
-function classifyODataPathIntent(path11, method) {
-  const rawPath = (path11 ?? "").trim();
+function classifyODataPathIntent(path12, method) {
+  const rawPath = (path12 ?? "").trim();
   const normalizedMethod = (method ?? "GET").trim().toUpperCase() || "GET";
   const queryIndex = rawPath.indexOf("?");
   const pathWithoutQuery = queryIndex >= 0 ? rawPath.slice(0, queryIndex) : rawPath;
@@ -1528,8 +2303,8 @@ function classifyODataPathIntent(path11, method) {
   if (/^[A-Z][A-Za-z0-9_]*$/.test(firstSegment)) return { ...base, kind: "entity_candidate", reason: "uppercase_collection_segment_without_indexed_entity_evidence" };
   return { ...base, kind: "unknown", reason: "get_path_has_no_query_key_or_navigation_signal" };
 }
-function entitySegmentFromPath(path11) {
-  const first = path11.replace(/^\//, "").split("/")[0]?.trim();
+function entitySegmentFromPath(path12) {
+  const first = path12.replace(/^\//, "").split("/")[0]?.trim();
   if (!first) return void 0;
   const open = first.indexOf("(");
   const entity = (open >= 0 ? first.slice(0, open) : first).trim();
@@ -1677,7 +2452,7 @@ function topLevelQueryIndex(text) {
 }
 
 // src/parsers/imported-wrapper-parser.ts
-import path9 from "path";
+import path10 from "path";
 import ts7 from "typescript";
 
 // src/parsers/operation-path-analysis.ts
@@ -1686,8 +2461,8 @@ var maxAliasDepth = 6;
 function analyzeOperationPath(expression, use, method = "POST") {
   if (!expression) return emptyAnalysis();
   const state = collectExpressionState(expression, use, 0, /* @__PURE__ */ new Set());
-  const paths = unique(state.paths.map(normalizeRawPath));
-  const normalized = unique(paths.flatMap((value) => normalizedCandidate(value, method)));
+  const paths = unique2(state.paths.map(normalizeRawPath));
+  const normalized = unique2(paths.flatMap((value) => normalizedCandidate(value, method)));
   const status = pathStatus(paths, state.placeholders, state.dynamic);
   const runtimeIdentifier = state.dynamic.at(-1)?.expression;
   return {
@@ -1696,8 +2471,8 @@ function analyzeOperationPath(expression, use, method = "POST") {
     normalizedOperationPath: status === "static" && normalized.length === 1 ? normalized[0] : void 0,
     candidateRawPaths: paths,
     candidateNormalizedOperationPaths: normalized,
-    placeholderKeys: unique([...state.placeholders, ...runtimeIdentifier ? [runtimeIdentifier] : []]),
-    sourceKind: unique(state.sourceKinds).join("+") || "unknown",
+    placeholderKeys: unique2([...state.placeholders, ...runtimeIdentifier ? [runtimeIdentifier] : []]),
+    sourceKind: unique2(state.sourceKinds).join("+") || "unknown",
     candidateIdentifier: ts6.isIdentifier(expression) ? expression.text : void 0,
     runtimeIdentifier,
     dynamicReassignments: state.dynamic,
@@ -1828,8 +2603,8 @@ function templateState(expression) {
     sourceKinds: ["template_with_placeholders"]
   };
 }
-function staticState(path11, sourceKind) {
-  return { paths: [path11], placeholders: [], dynamic: [], sourceKinds: [sourceKind] };
+function staticState(path12, sourceKind) {
+  return { paths: [path12], placeholders: [], dynamic: [], sourceKinds: [sourceKind] };
 }
 function dynamicState(expression, sourceKind = "dynamic_expression") {
   return {
@@ -1898,7 +2673,7 @@ function sourceLine(node) {
   const source = node.getSourceFile();
   return source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
 }
-function unique(values) {
+function unique2(values) {
   return [...new Set(values)].sort();
 }
 function emptyAnalysis() {
@@ -1914,7 +2689,7 @@ function emptyAnalysis() {
 }
 
 // src/parsers/imported-wrapper-parser.ts
-async function parseImportedWrapperCalls(repoPath, filePath, source, serviceBindings) {
+async function parseImportedWrapperCalls(repoPath, filePath, source, serviceBindings, context) {
   const imports = await importsFor(repoPath, filePath, source);
   const importedByLocal = new Map(imports.filter((item) => item.sourceFile).map((item) => [item.localName, item]));
   const calls = collectImportedCalls(source, importedByLocal);
@@ -1924,7 +2699,7 @@ async function parseImportedWrapperCalls(repoPath, filePath, source, serviceBind
     if (!ts7.isIdentifier(call.expression)) continue;
     const imported = importedByLocal.get(call.expression.text);
     if (!imported?.sourceFile) continue;
-    const spec = await loadWrapperSpec(repoPath, imported, cache, 0);
+    const spec = await loadWrapperSpec(repoPath, imported, cache, 0, context);
     const fact = spec ? wrapperCallFact(source, filePath, call, spec, serviceBindings) : void 0;
     if (fact) out.push(fact);
   }
@@ -1939,23 +2714,43 @@ function collectImportedCalls(source, imports) {
   visit(source);
   return calls;
 }
-async function loadWrapperSpec(repoPath, imported, cache, depth) {
+async function loadWrapperSpec(repoPath, imported, cache, depth, context) {
   if (!imported.sourceFile || depth > 5) return void 0;
   const key = `${imported.sourceFile}#${imported.exportedName}`;
   const existing = cache.get(key);
   if (existing) return existing;
-  const pending = inspectWrapper(repoPath, imported.sourceFile, imported.exportedName, cache, depth);
+  const pending = inspectWrapper(
+    repoPath,
+    imported.sourceFile,
+    imported.exportedName,
+    cache,
+    depth,
+    context
+  );
   cache.set(key, pending);
   return pending;
 }
-async function inspectWrapper(repoPath, sourceFile, exportedName, cache, depth) {
-  const source = await readSource(path9.join(repoPath, sourceFile));
+async function inspectWrapper(repoPath, sourceFile, exportedName, cache, depth, context) {
+  const source = await readSource(
+    path10.join(repoPath, sourceFile),
+    context,
+    sourceFile
+  );
   if (!source) return void 0;
   const named = findFunction(source, exportedName);
   if (!named) return void 0;
   const direct = directSendSpec(source, sourceFile, named.name, named.fn);
   if (direct) return direct;
-  return nestedSendSpec(repoPath, sourceFile, source, named.name, named.fn, cache, depth);
+  return nestedSendSpec(
+    repoPath,
+    sourceFile,
+    source,
+    named.name,
+    named.fn,
+    cache,
+    depth,
+    context
+  );
 }
 function directSendSpec(source, sourceFile, name, fn) {
   const params = parameterNames(fn);
@@ -1974,11 +2769,11 @@ function directSendSpec(source, sourceFile, name, fn) {
   const clientIndex = params.indexOf(receiver);
   const pathIndex = pathName ? params.indexOf(pathName) : -1;
   if (clientIndex < 0 || pathIndex < 0) return void 0;
-  const methodName = methodExpr && ts7.isIdentifier(methodExpr) ? methodExpr.text : void 0;
-  const methodIndex = methodName ? params.indexOf(methodName) : -1;
+  const methodName2 = methodExpr && ts7.isIdentifier(methodExpr) ? methodExpr.text : void 0;
+  const methodIndex = methodName2 ? params.indexOf(methodName2) : -1;
   return { clientIndex, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : void 0, methodLiteral: literal(methodExpr), sourceFile, sourceLine: lineOf3(source, fn), chain: [name] };
 }
-async function nestedSendSpec(repoPath, sourceFile, source, name, fn, cache, depth) {
+async function nestedSendSpec(repoPath, sourceFile, source, name, fn, cache, depth, context) {
   const imports = await importsFor(repoPath, sourceFile, source);
   const byLocal = new Map(imports.filter((item) => item.sourceFile).map((item) => [item.localName, item]));
   const calls = [];
@@ -1988,7 +2783,7 @@ async function nestedSendSpec(repoPath, sourceFile, source, name, fn, cache, dep
   if (calls.length !== 1) return void 0;
   const call = calls[0];
   const imported = call && ts7.isIdentifier(call.expression) ? byLocal.get(call.expression.text) : void 0;
-  const nested = imported ? await loadWrapperSpec(repoPath, imported, cache, depth + 1) : void 0;
+  const nested = imported ? await loadWrapperSpec(repoPath, imported, cache, depth + 1, context) : void 0;
   if (!call || !nested) return void 0;
   const params = parameterNames(fn);
   const clientIndex = mappedParameterIndex(call.arguments[nested.clientIndex], params);
@@ -2235,8 +3030,8 @@ function resolveExpression(expr, use, policy, depth = 0, seen = /* @__PURE__ */
     if (!binding.declaration || !binding.initializer || !binding.immutable) return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: binding.evidence, constName: expr.text };
     if (seen.has(binding.declaration)) return { status: "unknown", sourceKind: "const_alias", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: ["alias_cycle_detected"], constName: expr.text };
     seen.add(binding.declaration);
-    const resolved2 = resolveExpression(binding.initializer, binding.declaration, policy, depth + 1, seen);
-    return { ...resolved2, sourceKind: "const_alias", rawExpression: safeRaw(expr), constName: expr.text, evidence: [...binding.evidence, ...resolved2.evidence] };
+    const resolved3 = resolveExpression(binding.initializer, binding.declaration, policy, depth + 1, seen);
+    return { ...resolved3, sourceKind: "const_alias", rawExpression: safeRaw(expr), constName: expr.text, evidence: [...binding.evidence, ...resolved3.evidence] };
   }
   return { status: "dynamic", sourceKind: "dynamic_expression", rawExpression: safeRaw(expr), placeholderKeys: [], evidence: [`unsupported_${ts8.SyntaxKind[expr.kind] ?? "expression"}`] };
 }
@@ -2260,10 +3055,10 @@ function destinationExpressionShape(expr) {
   return ts8.SyntaxKind[expr.kind] ?? "expression";
 }
 function staticConditionalCandidates(expr, initializers) {
-  const resolved2 = expr && ts8.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
-  if (!resolved2 || !ts8.isConditionalExpression(resolved2)) return void 0;
-  const left = staticExpressionText(resolved2.whenTrue, initializers);
-  const right = staticExpressionText(resolved2.whenFalse, initializers);
+  const resolved3 = expr && ts8.isIdentifier(expr) && initializers.has(expr.text) ? initializers.get(expr.text) : expr;
+  if (!resolved3 || !ts8.isConditionalExpression(resolved3)) return void 0;
+  const left = staticExpressionText(resolved3.whenTrue, initializers);
+  const right = staticExpressionText(resolved3.whenFalse, initializers);
   if (!left || !right) return void 0;
   return [.../* @__PURE__ */ new Set([left, right])];
 }
@@ -2311,15 +3106,15 @@ function hasTemplatePlaceholder(value) {
   return /\$\{|%7B|%7D/i.test(value);
 }
 function urlTargetFromExpression(expr, use) {
-  const resolved2 = resolveExpression(expr, use, "external");
-  if (resolved2.status === "static" && resolved2.value && !hasTemplatePlaceholder(resolved2.value)) return { kind: "static_url", expression: resolved2.value, dynamic: false, sourceKind: resolved2.sourceKind };
-  if (expr) return { kind: "url_expression", dynamic: true, expression: `${resolved2.sourceKind}:${resolved2.placeholderKeys.join("|")}`, expressionShape: resolved2.sourceKind, placeholderKeys: resolved2.placeholderKeys };
+  const resolved3 = resolveExpression(expr, use, "external");
+  if (resolved3.status === "static" && resolved3.value && !hasTemplatePlaceholder(resolved3.value)) return { kind: "static_url", expression: resolved3.value, dynamic: false, sourceKind: resolved3.sourceKind };
+  if (expr) return { kind: "url_expression", dynamic: true, expression: `${resolved3.sourceKind}:${resolved3.placeholderKeys.join("|")}`, expressionShape: resolved3.sourceKind, placeholderKeys: resolved3.placeholderKeys };
   return { kind: "unknown", dynamic: false };
 }
 function destinationTargetFromExpression(expr, use) {
-  const resolved2 = resolveExpression(expr, use, "external");
-  const text = resolved2.value;
-  if (resolved2.status === "static" && text && !hasTemplatePlaceholder(text)) return { kind: "destination", expression: text, dynamic: false, sourceKind: resolved2.sourceKind };
+  const resolved3 = resolveExpression(expr, use, "external");
+  const text = resolved3.value;
+  if (resolved3.status === "static" && text && !hasTemplatePlaceholder(text)) return { kind: "destination", expression: text, dynamic: false, sourceKind: resolved3.sourceKind };
   const candidates = staticConditionalCandidates(expr, /* @__PURE__ */ new Map());
   if (candidates) return { kind: "destination", dynamic: true, expressionShape: "conditional", candidateLiterals: candidates };
   const shape = destinationExpressionShape(expr);
@@ -2419,9 +3214,9 @@ function collectWrapperSpecs(source) {
           const pathProp = propertyInitializer(objectArg, "path");
           const methodProp = propertyInitializer(objectArg, "method");
           const pathName = pathProp && ts8.isIdentifier(pathProp) ? pathProp.text : void 0;
-          const methodName = methodProp && ts8.isIdentifier(methodProp) ? methodProp.text : void 0;
+          const methodName2 = methodProp && ts8.isIdentifier(methodProp) ? methodProp.text : void 0;
           const methodLiteral = resolveExpression(methodProp, node, "literal").value;
-          if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
+          if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName2, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
       if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression) && specs.has(node.expression.text)) {
@@ -2558,15 +3353,37 @@ function containsSupportedOutboundCall(node) {
   const end = node.getEnd();
   return classifyOutboundCallsInSource(source, source.fileName).some((call) => call.node.getStart(source) >= start && call.node.getEnd() <= end);
 }
-async function parseOutboundCalls(repoPath, filePath) {
-  const text = await fs7.readFile(path10.join(repoPath, filePath), "utf8");
-  const source = ts8.createSourceFile(filePath, text, ts8.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS);
-  const bindingNames = new Set((await parseServiceBindings(repoPath, filePath)).map((binding) => binding.variableName));
-  const importedWrappers = await parseImportedWrapperCalls(repoPath, filePath, source, bindingNames);
-  return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...importedWrappers, ...parseLocalServiceCalls(text, filePath)];
-}
-function parseLocalServiceCalls(text, filePath) {
-  const source = ts8.createSourceFile(filePath, text, ts8.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS);
+async function parseOutboundCalls(repoPath, filePath, context) {
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text ?? await fs8.readFile(path11.join(repoPath, filePath), "utf8");
+  const source = snapshot?.sourceFile() ?? ts8.createSourceFile(
+    filePath,
+    text,
+    ts8.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS
+  );
+  const bindingNames = new Set((await parseServiceBindings(
+    repoPath,
+    filePath,
+    context
+  )).map((binding) => binding.variableName));
+  const importedWrappers = await parseImportedWrapperCalls(
+    repoPath,
+    filePath,
+    source,
+    bindingNames,
+    context
+  );
+  return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...importedWrappers, ...parseLocalServiceCalls(text, filePath, source)];
+}
+function parseLocalServiceCalls(text, filePath, source = ts8.createSourceFile(
+  filePath,
+  text,
+  ts8.ScriptTarget.Latest,
+  true,
+  filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS
+)) {
   const aliases = /* @__PURE__ */ new Map();
   const calls = [];
   const visit = (node) => {
@@ -2842,8 +3659,8 @@ function buildRemoteQueryTarget(input) {
 // src/linker/service-resolver.ts
 function rows(db, operationPath, workspaceId) {
   const names = operationLookupNames(operationPath);
-  return db.prepare(
-    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score,'' reasons
+  const result = db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score
        FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
        WHERE (? IS NULL OR r.workspace_id=?) AND (o.operation_path IN (?,?) OR o.operation_name IN (?,?)) ORDER BY r.name,s.service_path,o.operation_name`
   ).all(
@@ -2854,6 +3671,11 @@ function rows(db, operationPath, workspaceId) {
     names.name,
     names.simpleName
   );
+  return result.map((row) => ({
+    ...row,
+    score: Number(row.score ?? 0),
+    reasons: []
+  }));
 }
 function operationLookupNames(operationPath) {
   const name = operationPath.replace(/^\//, "");
@@ -2870,7 +3692,11 @@ function resolveOperation(db, signals, workspaceId) {
   if (missing.length > 0)
     return {
       status: "dynamic",
-      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId) : [],
+      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId).map((candidate) => ({
+        ...candidate,
+        score: 0.2,
+        reasons: ["operation_path_match"]
+      })) : [],
       reasons: [...new Set(missing)].map((name) => `missing_variable:${name}`)
     };
   if (!signals.operationPath)
@@ -3233,7 +4059,13 @@ function compactCandidateScores(candidates) {
   return candidates.flatMap((candidate) => {
     const row = objectValue(candidate);
     if (!row) return [];
-    return [{ repo: row.repoName, servicePath: row.servicePath, operationPath: row.operationPath, score: row.score, reasons: row.reasons }];
+    return [{
+      repo: row.repoName,
+      servicePath: row.servicePath,
+      operationPath: row.operationPath,
+      score: row.score,
+      reasons: Array.isArray(row.reasons) ? row.reasons.filter((reason) => typeof reason === "string") : ["operation_path_match"]
+    }];
   });
 }
 function placeholderKeys(values) {
@@ -3262,7 +4094,7 @@ function linkImplementations(db, workspaceId, generation) {
     const duplicateFamilies = duplicatePackageFamilies(accepted);
     const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
     const selected = duplicatePackageAmbiguous ? accepted : winners;
-    const unique2 = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : void 0;
+    const unique3 = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : void 0;
     const ambiguityReasons = duplicatePackageAmbiguous ? ["duplicate_package_name_candidates"] : winners.length > 1 ? ["multiple_equal_score_implementation_candidates"] : [];
     const evidence = {
       servicePath: operation.servicePath,
@@ -3276,16 +4108,16 @@ function linkImplementations(db, workspaceId, generation) {
       candidateFamilies: duplicateFamilies,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1))
     };
-    const evidenceWithHints = unique2 ? evidence : { ...evidence, implementationHintSuggestions: implementationHintSuggestions(evidence) };
+    const evidenceWithHints = unique3 ? evidence : { ...evidence, implementationHintSuggestions: implementationHintSuggestions(evidence) };
     if (accepted.length === 0) {
       db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "OPERATION_IMPLEMENTED_BY_HANDLER", "unresolved", "operation", graphId(operation.operationId), "handler_method_candidates", candidates.map((row) => graphId(row.methodId)).join(","), 0, JSON.stringify(evidenceWithHints), 0, "No implementation candidate passed policy", generation);
       edgeCount += 1;
       unresolvedCount += 1;
       continue;
     }
-    db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "OPERATION_IMPLEMENTED_BY_HANDLER", unique2 ? "resolved" : "ambiguous", "operation", graphId(operation.operationId), unique2 ? "handler_method" : "handler_method_candidates", unique2 ? graphId(unique2.methodId) : selected.map((row) => graphId(row.methodId)).join(","), unique2 ? 0.95 : 0.5, JSON.stringify(evidenceWithHints), 0, unique2 ? null : "Ambiguous registered handler implementation candidates", generation);
+    db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, "OPERATION_IMPLEMENTED_BY_HANDLER", unique3 ? "resolved" : "ambiguous", "operation", graphId(operation.operationId), unique3 ? "handler_method" : "handler_method_candidates", unique3 ? graphId(unique3.methodId) : selected.map((row) => graphId(row.methodId)).join(","), unique3 ? 0.95 : 0.5, JSON.stringify(evidenceWithHints), 0, unique3 ? null : "Ambiguous registered handler implementation candidates", generation);
     edgeCount += 1;
-    if (unique2) resolvedCount += 1;
+    if (unique3) resolvedCount += 1;
     else ambiguousCount += 1;
   }
   return { edgeCount, resolvedCount, ambiguousCount, unresolvedCount };
@@ -3428,7 +4260,7 @@ function implementationCandidates(db, workspaceId, operation) {
       CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id AND localService.service_path=?) THEN 1 ELSE 0 END localServicePathMatch,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
-      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id)) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
+      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id)) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND COALESCE(json_extract(localMethod.decorator_resolution_json,'$.handlerKind'),CASE WHEN localMethod.decorator_kind='Event' THEN 'event' WHEN localMethod.decorator_kind IN ('Action','Func','On') THEN 'operation' ELSE 'unsupported' END)='operation' AND COALESCE(json_extract(localMethod.decorator_resolution_json,'$.executable'),CASE WHEN localMethod.decorator_kind IN ('Action','Func','On') THEN 1 ELSE 0 END)=1 AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END appDependsOnModel,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END handlerDependsOnModel
@@ -3460,6 +4292,13 @@ function implementationCandidates(db, workspaceId, operation) {
     )
     JOIN repositories appRepo ON appRepo.id=hr.repo_id
     WHERE appRepo.workspace_id=?
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
+        CASE WHEN hm.decorator_kind='Event' THEN 'event'
+          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
+          ELSE 'unsupported' END)='operation'
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
+          THEN 1 ELSE 0 END)=1
       AND (hm.decorator_value=? OR hm.decorator_value=? OR hm.method_name=? OR hm.decorator_raw_expression LIKE ?)`).all(
     operation.modelRepoId,
     operation.modelRepo,
@@ -3588,6 +4427,11 @@ function candidateEvidence(candidate, rank) {
   };
 }
 function implementationMethodSignal(row, operation) {
+  const resolution = objectJson(row.decoratorResolutionJson) ?? {};
+  if (resolution.handlerKind && resolution.handlerKind !== "operation")
+    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["non_operation_handler_kind"] };
+  if (resolution.executable === false)
+    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["handler_method_not_executable"] };
   const op = normalizedOperationName(String(operation.operationPath ?? operation.operationName ?? ""));
   const decorator = normalizeDecoratorOperationSignal(typeof row.decoratorValue === "string" ? row.decoratorValue : void 0, typeof row.decoratorRawExpression === "string" ? row.decoratorRawExpression : void 0, op);
   if (decorator.status === "resolved" && decorator.operationName === op) return { matches: true, contradicted: false, acceptedReasons: ["decorator targets operation"], rejectedReasons: [] };
@@ -3617,101 +4461,1337 @@ function parseVars(values) {
   }
   return out;
 }
-function ambiguousStartDiagnostic(requested, candidates, message) {
-  const serviceSuggestions = [...new Set(candidates.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
+function selectorRepoNotFoundDiagnostic(requested) {
   return {
     severity: "warning",
-    code: "trace_start_ambiguous",
-    message,
-    normalizedSelectorValue: requested,
-    resolutionStage: "operation",
-    resolutionStatus: "ambiguous_operation",
-    candidates,
-    serviceSuggestions,
-    selectorSuggestions: fullSelectorSuggestions(candidates)
+    code: "selector_repo_not_found",
+    message: `No indexed repository matched selector: ${requested}`,
+    selectorKind: "repo",
+    requestedRepository: requested
   };
 }
-function fullSelectorSuggestions(candidates) {
-  const includeRepo = new Set(candidates.map((row) => row.repoName)).size > 1;
-  return [...new Set(candidates.flatMap((row) => {
-    if (typeof row.servicePath !== "string" || typeof row.operationPath !== "string") return [];
-    const repoSelector = includeRepo && typeof row.repoName === "string" ? `--repo ${row.repoName} ` : "";
-    return [
-      `${repoSelector}--service ${row.servicePath} --path ${row.operationPath}`
-    ];
-  }))].sort();
+function selectorRepoAmbiguousDiagnostic(requested, candidates) {
+  const uniqueName = (value) => candidates.filter((candidate) => candidate.name === value).length === 1;
+  const uniquePackage = (value) => candidates.filter((candidate) => candidate.packageName === value).length === 1;
+  const suggestions = candidates.flatMap((candidate) => {
+    if (uniqueName(candidate.name)) return [`--repo ${candidate.name}`];
+    if (candidate.packageName && uniquePackage(candidate.packageName))
+      return [`--repo ${candidate.packageName}`];
+    return [];
+  });
+  return {
+    severity: "warning",
+    code: "selector_repo_ambiguous",
+    message: `Repository selector matched multiple indexed repositories: ${requested}`,
+    selectorKind: "repo",
+    requestedRepository: requested,
+    candidates,
+    selectorSuggestions: [...new Set(suggestions)].sort(),
+    remediation: suggestions.length > 0 ? "Use one of the unique --repo selectors shown." : "Repository names and package names must be unique before this selector can be traced safely."
+  };
 }
-
-// src/trace/evidence.ts
-function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
-  const evidence = { ...persistedEvidence, ...contextualEvidence ?? {} };
+function selectorNotFoundDiagnostic(start) {
+  const serviceOnly = start.servicePath && !start.operation && !start.operationPath && !start.handler;
   return {
-    ...evidence,
-    graphEdgeId: row.id,
-    persistedGraphEdgeId: row.id > 0 ? row.id : void 0,
-    outboundCallId: call.id,
-    callSite: { sourceFile: call.source_file, sourceLine: call.source_line },
-    sourceFile: call.source_file,
-    sourceLine: call.source_line,
-    file: call.source_file,
-    line: call.source_line,
-    persistedTarget: { kind: row.to_kind, id: row.to_id },
-    contextualResolutionParticipated: Boolean(contextualEvidence?.contextualServiceBindingAttempted),
-    persistedResolution: persistedResolution(row)
+    severity: "warning",
+    code: "trace_start_not_found",
+    message: serviceOnly ? "Service-only trace requires --operation or --path and will not broaden to the whole workspace" : "No handler source matched the requested trace start selector",
+    selectorKind: start.handler ? "handler" : start.operation || start.operationPath ? "operation" : start.servicePath ? "service" : void 0
   };
 }
-function runtimeResolution(db, row, evidence, vars, workspaceId, contextualUnresolvedReason) {
-  const substituted = evidenceWithRuntimeVariables(evidence, vars);
-  if (!isRemoteRuntimeCandidate(row, evidence, vars)) {
-    const unresolvedReason2 = contextualUnresolvedReason ?? row.unresolved_reason;
-    const withSections = withEffectiveResolution(substituted, row, unresolvedReason2);
-    return { row, evidence: withSections, unresolvedReason: unresolvedReason2 };
-  }
-  const resolution = resolveRuntimeOperation(db, substituted, workspaceId);
-  if (resolution.target) {
-    const resolvedRow = { ...row, status: "resolved", to_kind: "operation", to_id: String(resolution.target.operationId), unresolved_reason: void 0, confidence: Math.max(0, Math.min(1, resolution.target.score)) };
-    return { row: resolvedRow, evidence: withEffectiveResolution(substituted, resolvedRow, void 0, resolution), target: resolution.target };
+function sourceScopeForSelector(db, repoId, start, workspaceId) {
+  if (start.handler) {
+    const classRows = handlerClassRows(db, repoId, start.handler, workspaceId);
+    if (classRows.length > 0) return handlerClassScope(classRows, start.handler);
+    const methodRows = handlerMethodRows(db, repoId, start.handler, workspaceId);
+    if (methodRows.length > 0)
+      return handlerMethodScope(methodRows, repoId, start.handler);
   }
-  const unresolvedReason = runtimeUnresolvedReason(resolution);
-  return { row, evidence: withEffectiveResolution(substituted, row, unresolvedReason, resolution), unresolvedReason };
-}
-function runtimeVariableDiagnostic(edges) {
-  const missing = /* @__PURE__ */ new Set();
-  for (const edge of edges) {
-    const effective = parseObject(edge.evidence.effectiveResolution);
-    if (!["dynamic", "unresolved", "ambiguous"].includes(String(effective.status ?? "")))
-      continue;
-    const substitutions = edge.evidence.runtimeSubstitutions;
-    if (!substitutions || typeof substitutions !== "object" || Array.isArray(substitutions)) continue;
-    for (const value of Object.values(substitutions))
-      for (const key of value.missing ?? []) missing.add(key);
+  const operation = normalizeOperation(start.operation ?? start.operationPath);
+  if (!operation) return void 0;
+  const operationRows = operationHandlerRows(
+    db,
+    repoId,
+    operation,
+    start.servicePath,
+    workspaceId
+  );
+  if (operationRows.length > 0)
+    return operationHandlerScope(operationRows, repoId, operation);
+  if (!start.servicePath) return void 0;
+  const implementationRows = implementationHandlerRows(
+    db,
+    repoId,
+    start.servicePath,
+    operation,
+    workspaceId
+  );
+  return implementationRows.length > 0 ? executableScope(implementationRows, repoId) : void 0;
+}
+function handlerClassRows(db, repoId, handler, workspaceId) {
+  return db.prepare(`SELECT hc.id handlerClassId,hc.repo_id repoId,
+      r.name repoName,hc.class_name className,
+      hc.source_file sourceFile,hc.source_line sourceLine,hm.id methodId,
+      sym.id symbolId,COALESCE(classSym.evidence_json,
+        (SELECT fallback.evidence_json FROM symbols fallback
+         WHERE fallback.repo_id=hc.repo_id AND fallback.kind='class'
+           AND fallback.name=hc.class_name AND fallback.source_file=hc.source_file
+         ORDER BY fallback.id LIMIT 1)) classEvidence
+    FROM handler_classes hc
+    JOIN repositories r ON r.id=hc.repo_id
+    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
+      AND sym.source_file=hc.source_file
+      AND sym.kind='method'
+      AND substr(sym.qualified_name,1,length(hc.class_name)+1)=hc.class_name || '.'
+      AND (NOT EXISTS (SELECT 1 FROM handler_methods declared
+            WHERE declared.handler_class_id=hc.id
+              AND declared.method_name=sym.name)
+        OR EXISTS (SELECT 1 FROM handler_methods executable
+            WHERE executable.handler_class_id=hc.id
+              AND executable.method_name=sym.name
+              AND COALESCE(json_extract(executable.decorator_resolution_json,
+                '$.executable'),CASE WHEN executable.decorator_kind IN
+                ('Action','Func','On','Event') THEN 1 ELSE 0 END)=1))
+    LEFT JOIN handler_methods hm ON hm.handler_class_id=hc.id
+      AND hm.method_name=sym.name
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On','Event')
+          THEN 1 ELSE 0 END)=1
+    LEFT JOIN symbols classSym ON classSym.id=hc.symbol_id
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND (? IS NULL OR hc.repo_id=?) AND hc.class_name=?
+    ORDER BY hc.repo_id,hc.id,hm.id`).all(
+    workspaceId,
+    workspaceId,
+    repoId,
+    repoId,
+    handler
+  );
+}
+function handlerMethodRows(db, repoId, handler, workspaceId) {
+  return db.prepare(`SELECT hc.id handlerClassId,hc.repo_id repoId,
+      r.name repoName,hc.class_name className,hc.source_file sourceFile,
+      hm.source_line sourceLine,hm.id methodId,sym.id symbolId
+    FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    JOIN repositories r ON r.id=hc.repo_id
+    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
+      AND sym.source_file=hc.source_file
+      AND sym.qualified_name=hc.class_name || '.' || hm.method_name
+      AND sym.start_line=hm.source_line
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND (? IS NULL OR hc.repo_id=?) AND hm.method_name=?
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On','Event')
+          THEN 1 ELSE 0 END)=1
+    ORDER BY hc.repo_id,hc.id,hm.id`).all(
+    workspaceId,
+    workspaceId,
+    repoId,
+    repoId,
+    handler
+  );
+}
+function operationHandlerRows(db, repoId, operation, servicePath, workspaceId) {
+  return db.prepare(`SELECT DISTINCT hc.id handlerClassId,hc.repo_id repoId,
+      r.name repoName,hc.class_name className,hc.source_file sourceFile,
+      hm.source_line sourceLine,hm.id methodId,sym.id symbolId
+    FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    JOIN repositories r ON r.id=hc.repo_id
+    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
+      AND sym.source_file=hc.source_file
+      AND sym.qualified_name=hc.class_name || '.' || hm.method_name
+      AND sym.start_line=hm.source_line
+    WHERE (? IS NULL OR r.workspace_id=?) AND (? IS NULL OR hc.repo_id=?)
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
+        CASE WHEN hm.decorator_kind='Event' THEN 'event'
+          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
+          ELSE 'unsupported' END)='operation'
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
+          THEN 1 ELSE 0 END)=1
+      AND (hm.decorator_value=? OR hm.method_name=?)
+      AND (? IS NULL OR EXISTS (
+        SELECT 1 FROM cds_services svc JOIN cds_operations op ON op.service_id=svc.id
+        WHERE svc.repo_id=hc.repo_id AND svc.service_path=?
+          AND (op.operation_path=? OR op.operation_name=?)))
+    ORDER BY hc.repo_id,hc.id,hm.id`).all(
+    workspaceId,
+    workspaceId,
+    repoId,
+    repoId,
+    operation,
+    operation,
+    servicePath,
+    servicePath,
+    operation,
+    operation
+  );
+}
+function operationHandlerScope(rows2, fallbackRepoId, requested) {
+  const candidates = handlerSelectorCandidates(rows2, "method");
+  if (candidates.length < 2) return executableScope(rows2, fallbackRepoId);
+  const classes = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = `${String(candidate.repoName)}:${String(candidate.className)}`;
+    classes.set(key, /* @__PURE__ */ new Set([
+      ...classes.get(key) ?? [],
+      String(candidate.handlerClassId)
+    ]));
+  }
+  const suggestions = candidates.flatMap((candidate) => {
+    if (typeof candidate.repoName !== "string" || typeof candidate.className !== "string") return [];
+    const key = `${candidate.repoName}:${candidate.className}`;
+    return classes.get(key)?.size === 1 ? [`--repo ${candidate.repoName} --handler ${candidate.className}`] : [];
+  });
+  return { diagnostics: [{
+    severity: "warning",
+    code: "trace_start_ambiguous",
+    message: "Operation selector matched multiple handler-only executable scopes",
+    selectorKind: "operation",
+    normalizedSelectorValue: requested,
+    resolutionStage: "handler",
+    resolutionStatus: "ambiguous_handler_operation",
+    candidates,
+    selectorSuggestions: [...new Set(suggestions)].sort(),
+    remediation: "Select one handler class explicitly; no operation was chosen automatically."
+  }] };
+}
+function implementationHandlerRows(db, repoId, servicePath, operation, workspaceId) {
+  return db.prepare(`SELECT DISTINCT hc.repo_id repoId,
+      hc.source_file sourceFile,hm.id methodId,sym.id symbolId
+    FROM cds_services svc JOIN cds_operations op ON op.service_id=svc.id
+    JOIN repositories r ON r.id=svc.repo_id
+    JOIN graph_edges edge ON edge.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER'
+      AND edge.status='resolved' AND edge.from_kind='operation'
+      AND edge.from_id=CAST(op.id AS TEXT)
+    JOIN handler_methods hm ON hm.id=CAST(edge.to_id AS INTEGER)
+    JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
+      AND sym.source_file=hc.source_file
+      AND sym.qualified_name=hc.class_name || '.' || hm.method_name
+      AND sym.start_line=hm.source_line
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND (? IS NULL OR svc.repo_id=?) AND svc.service_path=?
+      AND (op.operation_path=? OR op.operation_name=?)
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
+        CASE WHEN hm.decorator_kind='Event' THEN 'event'
+          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
+          ELSE 'unsupported' END)='operation'
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
+          THEN 1 ELSE 0 END)=1
+    ORDER BY hc.repo_id,hc.id,hm.id`).all(
+    workspaceId,
+    workspaceId,
+    repoId,
+    repoId,
+    servicePath,
+    operation,
+    operation
+  );
+}
+function handlerClassScope(rows2, requested) {
+  const ambiguity = handlerSelectorAmbiguity(rows2, requested, "class");
+  if (ambiguity) return { diagnostics: [ambiguity] };
+  const executable = rows2.filter((row) => typeof row.symbolId === "number");
+  const repoId = numericValue(rows2[0]?.repoId);
+  if (executable.length > 0) {
+    const scope = executableScope(executable, repoId);
+    const warning = executable.some((row) => typeof row.methodId === "number") ? handlerDecoratorsNotIndexedDiagnostic(rows2[0]) : handlerMethodsNotIndexedDiagnostic(rows2[0]);
+    return warning ? { ...scope, diagnostics: [warning] } : scope;
+  }
+  const first = rows2[0];
+  return {
+    repoId,
+    diagnostics: [handlerMethodsNotIndexedDiagnostic(first)]
+  };
+}
+function handlerMethodScope(rows2, fallbackRepoId, requested) {
+  const ambiguity = handlerSelectorAmbiguity(rows2, requested, "method");
+  return ambiguity ? { diagnostics: [ambiguity] } : executableScope(rows2, fallbackRepoId);
+}
+function handlerSelectorAmbiguity(rows2, requested, matchKind) {
+  const candidates = handlerSelectorCandidates(rows2, matchKind);
+  if (candidates.length < 2) return void 0;
+  const repoCounts = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    if (typeof candidate.repoName !== "string") continue;
+    repoCounts.set(
+      candidate.repoName,
+      (repoCounts.get(candidate.repoName) ?? 0) + 1
+    );
+  }
+  const suggestions = candidates.flatMap((candidate) => {
+    const repoName = typeof candidate.repoName === "string" ? candidate.repoName : void 0;
+    if (repoName && repoCounts.get(repoName) === 1)
+      return [`--repo ${repoName} --handler ${requested}`];
+    if (matchKind === "method" && typeof candidate.className === "string")
+      return [`${repoName ? `--repo ${repoName} ` : ""}--handler ${candidate.className}`];
+    return [];
+  });
+  return {
+    severity: "warning",
+    code: "trace_start_ambiguous",
+    message: "Handler selector matched multiple executable scopes and was not selected automatically",
+    selectorKind: "handler",
+    requestedHandler: requested,
+    resolutionStage: "handler",
+    resolutionStatus: "ambiguous_handler",
+    candidates,
+    selectorSuggestions: [...new Set(suggestions)].sort(),
+    remediation: suggestions.length > 0 ? "Use one of the scoped handler selectors shown." : "No current CLI selector uniquely identifies these duplicate handler classes."
+  };
+}
+function handlerSelectorCandidates(rows2, matchKind) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const row of rows2) {
+    const identity = matchKind === "class" ? `class:${String(row.handlerClassId)}` : `method:${String(row.repoId)}:${String(row.symbolId ?? row.methodId)}`;
+    candidates.set(identity, {
+      handlerClassId: row.handlerClassId,
+      repoId: row.repoId,
+      repoName: row.repoName,
+      className: row.className,
+      sourceFile: row.sourceFile,
+      sourceLine: row.sourceLine,
+      matchKind
+    });
+  }
+  return [...candidates.values()].sort((left, right) => String(left.repoName ?? "").localeCompare(String(right.repoName ?? "")) || String(left.className ?? "").localeCompare(String(right.className ?? "")) || String(left.sourceFile ?? "").localeCompare(String(right.sourceFile ?? "")));
+}
+function executableScope(rows2, fallbackRepoId) {
+  const files = rows2.flatMap((row) => row.sourceFile ? [row.sourceFile] : []);
+  const symbols = rows2.flatMap((row) => typeof row.symbolId === "number" ? [row.symbolId] : []);
+  if (files.length === 0 || symbols.length === 0) return { repoId: fallbackRepoId };
+  return {
+    files: new Set(files),
+    symbols: new Set(symbols),
+    repoId: numericValue(rows2[0]?.repoId) ?? fallbackRepoId
+  };
+}
+function handlerMethodsNotIndexedDiagnostic(row) {
+  return {
+    severity: "warning",
+    code: "handler_methods_not_indexed",
+    message: `Handler class ${row?.className ?? "unknown"} has no indexed executable methods`,
+    selectorKind: "handler",
+    className: row?.className,
+    sourceFile: row?.sourceFile,
+    sourceLine: row?.sourceLine,
+    observedDecoratorNames: stringEvidenceArray(
+      row?.classEvidence,
+      "observedDecoratorNames"
+    ),
+    unsupportedDecoratorNames: stringEvidenceArray(
+      row?.classEvidence,
+      "unsupportedDecoratorNames"
+    ),
+    remediation: "Use a supported CAP handler decorator on at least one class method and re-index the workspace."
+  };
+}
+function handlerDecoratorsNotIndexedDiagnostic(row) {
+  const names = stringEvidenceArray(
+    row?.classEvidence,
+    "unsupportedDecoratorNames"
+  );
+  const methods = arrayEvidence(row?.classEvidence, "unsupportedMethods");
+  if (names.length === 0 && methods.length === 0) return void 0;
+  return {
+    severity: "warning",
+    code: "handler_decorators_not_indexed",
+    message: `Handler class ${row?.className ?? "unknown"} contains methods that were not indexed`,
+    selectorKind: "handler",
+    className: row?.className,
+    sourceFile: row?.sourceFile,
+    sourceLine: row?.sourceLine,
+    unsupportedDecoratorNames: names,
+    unsupportedMethods: methods,
+    remediation: "Use a supported CAP handler decorator shape and re-index the workspace."
+  };
+}
+function evidenceRecord(evidenceJson) {
+  if (!evidenceJson) return {};
+  try {
+    const parsed = JSON.parse(evidenceJson);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function stringEvidenceArray(evidenceJson, key) {
+  const value = evidenceRecord(evidenceJson)[key];
+  return Array.isArray(value) ? [...new Set(value.filter((item) => typeof item === "string"))].sort() : [];
+}
+function arrayEvidence(evidenceJson, key) {
+  const value = evidenceRecord(evidenceJson)[key];
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+}
+function numericValue(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function normalizeOperation(value) {
+  if (!value) return void 0;
+  return value.startsWith("/") ? value.slice(1) : value;
+}
+function ambiguousStartDiagnostic(requested, candidates, message) {
+  const serviceSuggestions = [...new Set(candidates.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
+  return {
+    severity: "warning",
+    code: "trace_start_ambiguous",
+    message,
+    normalizedSelectorValue: requested,
+    resolutionStage: "operation",
+    resolutionStatus: "ambiguous_operation",
+    candidates,
+    serviceSuggestions,
+    selectorSuggestions: fullSelectorSuggestions(candidates)
+  };
+}
+function fullSelectorSuggestions(candidates) {
+  const includeRepo = new Set(candidates.map((row) => row.repoName)).size > 1;
+  return [...new Set(candidates.flatMap((row) => {
+    if (typeof row.servicePath !== "string" || typeof row.operationPath !== "string") return [];
+    const repoSelector = includeRepo && typeof row.repoName === "string" ? `--repo ${row.repoName} ` : "";
+    return [
+      `${repoSelector}--service ${row.servicePath} --path ${row.operationPath}`
+    ];
+  }))].sort();
+}
+
+// src/trace/001-dynamic-identity.ts
+function uniqueIdentityDerivations(db, candidates, templates) {
+  const identities = workspaceIdentities(db, candidates);
+  const proposals = candidates.flatMap((candidate) => {
+    const owner = implementationOwner(db, candidate.candidateOperationId);
+    const identity = identities.find((item) => item.repoId === candidate.repoId);
+    return ownerAgrees(candidate, owner) && identity ? identityProposals(candidate, identity, templates) : [];
+  });
+  const matches2 = workspaceIdentityMatches(identities, templates);
+  const competing = competingIdentityKeys(matches2);
+  const duplicates = duplicateNormalizedIdentities(identities);
+  return proposals.filter((proposal) => !competing.has(`${proposal.key}:${proposal.value}`)).filter((proposal) => !duplicates.has(proposal.normalizedIdentity)).map((proposal) => ({
+    operationId: proposal.operationId,
+    key: proposal.key,
+    value: proposal.value,
+    provenance: proposal.provenance
+  }));
+}
+function identityProposals(candidate, identity, templates) {
+  const routeTemplates = [templates.alias, templates.destination].filter((value) => Boolean(value));
+  const identities = [
+    { name: identity.packageName, sourceKind: "package_identity", npmPackage: true },
+    { name: identity.repoName, sourceKind: "repository_identity", npmPackage: false }
+  ].filter((item) => Boolean(item.name));
+  const proposals = routeTemplates.flatMap((template) => identities.flatMap((identity2) => proposalForIdentity(
+    candidate,
+    template,
+    identity2.name,
+    identity2.sourceKind,
+    identity2.npmPackage
+  )));
+  return deduplicateProposals(proposals);
+}
+function proposalForIdentity(candidate, template, identity, sourceKind, npmPackage) {
+  const match = matchIdentityTemplate(template, identity, npmPackage);
+  if (!match) return [];
+  return [{
+    operationId: candidate.candidateOperationId,
+    key: match.key,
+    value: match.value,
+    normalizedIdentity: match.normalizedIdentity,
+    provenance: {
+      sourceKind,
+      value: match.value,
+      rule: "exact_normalized_identity_template_match",
+      template,
+      matchedName: identity,
+      normalizedForm: match.normalizedIdentity,
+      sourceRepo: candidate.repoName
+    }
+  }];
+}
+function matchIdentityTemplate(template, identity, npmPackage) {
+  const matches2 = [...template.matchAll(/\$\{([^}]*)\}/g)];
+  if (matches2.length !== 1 || !matches2[0]?.[1]) return void 0;
+  const placeholder = matches2[0][0];
+  const sentinel = "dynamicplaceholdertoken";
+  const normalizedTemplate = normalizeIdentity(template.replace(placeholder, sentinel));
+  const [prefix, suffix, extra] = normalizedTemplate.split(sentinel);
+  if (!prefix || !suffix || extra !== void 0) return void 0;
+  const normalizedIdentity = normalizeIdentity(identity, npmPackage);
+  const match = new RegExp(`^${escapeRegex(prefix)}([a-z0-9]+)${escapeRegex(suffix)}$`).exec(normalizedIdentity);
+  if (!match?.[1]) return void 0;
+  return { key: matches2[0][1].trim(), value: match[1], normalizedIdentity };
+}
+function competingIdentityKeys(proposals) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const proposal of proposals) {
+    const key = `${proposal.key}:${proposal.value}`;
+    owners.set(key, /* @__PURE__ */ new Set([...owners.get(key) ?? [], proposal.ownerKey]));
+  }
+  return new Set([...owners.entries()].filter(([, repos]) => repos.size > 1).map(([key]) => key));
+}
+function duplicateNormalizedIdentities(identities) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const identity of identities) {
+    for (const [name, npmPackage] of [
+      [identity.packageName, true],
+      [identity.repoName, false]
+    ]) {
+      if (!name) continue;
+      const normalized = normalizeIdentity(name, npmPackage);
+      owners.set(normalized, /* @__PURE__ */ new Set([
+        ...owners.get(normalized) ?? [],
+        `repository:${identity.repoId}`
+      ]));
+    }
+  }
+  return new Set([...owners.entries()].filter(([, repos]) => repos.size > 1).map(([identity]) => identity));
+}
+function workspaceIdentityMatches(identities, templates) {
+  const routeTemplates = [templates.alias, templates.destination].filter((value) => Boolean(value));
+  return identities.flatMap((identity) => {
+    const names = [
+      { name: identity.packageName, npmPackage: true },
+      { name: identity.repoName, npmPackage: false }
+    ];
+    return routeTemplates.flatMap((template) => names.flatMap(({ name, npmPackage }) => {
+      if (!name) return [];
+      const match = matchIdentityTemplate(template, name, npmPackage);
+      return match ? [{
+        ownerKey: `repository:${identity.repoId}`,
+        key: match.key,
+        value: match.value,
+        normalizedIdentity: match.normalizedIdentity
+      }] : [];
+    }));
+  });
+}
+function workspaceIdentities(db, candidates) {
+  const repoIds = [...new Set(candidates.flatMap((candidate) => candidate.repoId === void 0 ? [] : [candidate.repoId]))].sort((a, b) => a - b);
+  if (repoIds.length === 0) return [];
+  const placeholders3 = repoIds.map(() => "?").join(",");
+  const rows2 = db.prepare(`SELECT id repoId,name repoName,package_name packageName
+    FROM repositories WHERE workspace_id IN (
+      SELECT DISTINCT workspace_id FROM repositories WHERE id IN (${placeholders3})
+    ) ORDER BY workspace_id,name,absolute_path,id`).all(...repoIds);
+  return rows2.flatMap((row) => {
+    const repoId = numberValue(row.repoId);
+    const repoName = stringValue4(row.repoName);
+    return repoId === void 0 || !repoName ? [] : [{
+      repoId,
+      repoName,
+      packageName: stringValue4(row.packageName)
+    }];
+  });
+}
+function deduplicateProposals(rows2) {
+  const sorted = [...rows2].sort((left, right) => left.operationId - right.operationId || left.key.localeCompare(right.key) || left.value.localeCompare(right.value) || left.provenance.sourceKind.localeCompare(right.provenance.sourceKind));
+  const seen = /* @__PURE__ */ new Set();
+  return sorted.filter((row) => {
+    const key = [row.operationId, row.key, row.value, row.normalizedIdentity].join(":");
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function ownerAgrees(candidate, owner) {
+  return candidate.repoId !== void 0 && owner?.repoId !== void 0 && owner.repoId === candidate.repoId;
+}
+function implementationOwner(db, operationId) {
+  const rows2 = db.prepare(
+    `SELECT r.id repoId
+     FROM graph_edges e JOIN handler_methods hm ON hm.id=CAST(e.to_id AS INTEGER)
+     JOIN handler_classes hc ON hc.id=hm.handler_class_id
+     JOIN repositories r ON r.id=hc.repo_id
+     WHERE e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND e.status='resolved'
+       AND e.from_kind='operation' AND e.from_id=?
+     ORDER BY r.id,hm.id,e.id`
+  ).all(String(operationId));
+  if (rows2.length !== 1) return void 0;
+  const row = rows2[0];
+  if (!row) return void 0;
+  return {
+    repoId: numberValue(row.repoId)
+  };
+}
+function normalizeIdentity(value, npmPackage = false) {
+  const unscoped = npmPackage && /^@[^/]+\/[^/]+$/.test(value) ? value.slice(value.indexOf("/") + 1) : value;
+  return unscoped.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function stringValue4(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/trace/003-dynamic-references.ts
+function dynamicReferenceRows(db, workspaceId, callerRepoId, callerRepo) {
+  if (callerRepoId === void 0 && callerRepo === void 0) return [];
+  const rows2 = db.prepare(
+    `SELECT COALESCE(b.alias,b.alias_expr) alias,b.destination_expr destination,
+      b.service_path_expr servicePath,'service_binding' sourceKind,r.name repoName,
+      b.source_file sourceFile,b.source_line sourceLine,0 sourcePriority
+     FROM service_bindings b JOIN repositories r ON r.id=b.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)
+       AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
+     UNION ALL
+     SELECT req.alias,req.destination,req.service_path,'cds_require',r.name,
+      'package.json',1,1 FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)
+       AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
+     ORDER BY sourcePriority,repoName,sourceFile,sourceLine`
+  ).all(
+    workspaceId,
+    workspaceId,
+    callerRepoId,
+    callerRepoId,
+    callerRepoId,
+    callerRepo,
+    workspaceId,
+    workspaceId,
+    callerRepoId,
+    callerRepoId,
+    callerRepoId,
+    callerRepo
+  );
+  return rows2.flatMap(referenceFromRow);
+}
+function dynamicReferenceProvenance(reference, kind, template, value) {
+  return {
+    sourceKind: `${reference.sourceKind}.${kind}`,
+    value,
+    rule: "exact_indexed_reference_template_match",
+    template,
+    sourceRepo: reference.repoName,
+    sourceFile: reference.sourceFile,
+    sourceLine: reference.sourceLine
+  };
+}
+function referenceFromRow(row) {
+  const sourceKind = row.sourceKind;
+  const repoName = stringValue5(row.repoName);
+  if (sourceKind !== "service_binding" && sourceKind !== "cds_require" || !repoName) return [];
+  return [{
+    alias: stringValue5(row.alias),
+    destination: stringValue5(row.destination),
+    servicePath: stringValue5(row.servicePath),
+    sourceKind,
+    repoName,
+    sourceFile: stringValue5(row.sourceFile),
+    sourceLine: numberValue2(row.sourceLine)
+  }];
+}
+function stringValue5(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/trace/dynamic-targets.ts
+function analyzeDynamicTargetCandidates(db, evidence, workspaceId, mode, maxCandidates) {
+  const inputs = analysisInputs(evidence);
+  if (inputs.required.length === 0) return void 0;
+  const targets = candidateTargets(db, evidence, workspaceId);
+  const references = dynamicReferenceRows(
+    db,
+    workspaceId,
+    inputs.callerRepoId,
+    inputs.callerRepo
+  );
+  const candidates = buildCandidates(db, targets, references, inputs);
+  applyUniqueIdentityEvidence(db, candidates, inputs);
+  finalizeCandidates(candidates, inputs.order);
+  const ranked = stableRank(candidates);
+  const inference = inferenceDecision(ranked);
+  applyModeState(ranked, mode, inference);
+  const viable = ranked.filter((candidate) => candidate.viable);
+  const rejected = ranked.filter((candidate) => candidate.rejected);
+  const shown = viable.slice(0, maxCandidates).map((candidate) => boundedCandidate(candidate, maxCandidates));
+  const shownRejected = rejected.slice(0, maxCandidates).map((candidate) => boundedCandidate(candidate, maxCandidates));
+  return {
+    mode,
+    maxCandidates,
+    candidateCount: ranked.length,
+    viableCandidateCount: viable.length,
+    rejectedCandidateCount: rejected.length,
+    shownCandidateCount: shown.length,
+    omittedCandidateCount: Math.max(0, viable.length - shown.length),
+    shownRejectedCandidateCount: shownRejected.length,
+    omittedRejectedCandidateCount: Math.max(0, rejected.length - shownRejected.length),
+    missingVariables: inputs.required.filter((key) => inputs.supplied[key] === void 0),
+    requiredVariables: inputs.required,
+    suppliedVariables: inputs.supplied,
+    appliedSuppliedVariables: requiredSuppliedVariables(inputs),
+    substitutedSignals: inputs.effective,
+    candidates: shown,
+    shownCandidates: shown,
+    rejectedCandidates: shownRejected,
+    suggestedVarSets: suggestedVarSets(viable, inputs.order, maxCandidates),
+    inference
+  };
+}
+function analysisInputs(evidence) {
+  const original = templatesFromEvidence(evidence, "original");
+  const effective = templatesFromEvidence(evidence, "effective");
+  const requiredSources = placeholderSources(original);
+  const required = Object.keys(requiredSources);
+  const supplied = stringRecord(evidence.suppliedRuntimeVariables);
+  return {
+    original,
+    effective,
+    required,
+    requiredSources,
+    supplied,
+    order: variableOrder(original, required),
+    callerRepo: stringValue6(evidence.repo),
+    callerRepoId: numberValue3(evidence.repoId)
+  };
+}
+function candidateTargets(db, evidence, workspaceId) {
+  const embedded = rowsFromEvidence(evidence.candidates);
+  if (embedded.length > 0) return embedded;
+  const operationPath = effectiveSignal(evidence, "operationPath");
+  if (!operationPath || extractPlaceholders(operationPath).length > 0) return [];
+  return queryOperationTargets(db, operationPath, workspaceId);
+}
+function rowsFromEvidence(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const row = record(item);
+    const operationId = numberValue3(row.operationId);
+    const repoName = stringValue6(row.repoName);
+    const servicePath = stringValue6(row.servicePath);
+    const operationPath = stringValue6(row.operationPath);
+    const operationName = stringValue6(row.operationName) ?? operationPath?.replace(/^\//, "");
+    if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName) return [];
+    return [{
+      operationId,
+      repoId: numberValue3(row.repoId),
+      repoName,
+      packageName: stringValue6(row.packageName),
+      serviceName: stringValue6(row.serviceName) ?? "",
+      qualifiedName: stringValue6(row.qualifiedName) ?? "",
+      servicePath,
+      operationPath,
+      operationName,
+      sourceFile: stringValue6(row.sourceFile) ?? "",
+      sourceLine: numberValue3(row.sourceLine) ?? 0,
+      score: numberValue3(row.score) ?? 0,
+      reasons: stringArray(row.reasons)
+    }];
+  });
+}
+function queryOperationTargets(db, operationPath, workspaceId) {
+  const simple = operationPath.replace(/^\//, "").split(".").at(-1) ?? operationPath;
+  const rows2 = db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
+      s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,
+      o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,
+      o.source_line sourceLine FROM cds_operations o
+     JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
+     WHERE (? IS NULL OR r.workspace_id=?)
+       AND (o.operation_path IN (?,?) OR o.operation_name=?)
+     ORDER BY r.name,s.service_path,o.operation_name,o.id`
+  ).all(workspaceId, workspaceId, operationPath, `/${simple}`, simple);
+  return rows2.flatMap(operationTargetFromRow);
+}
+function operationTargetFromRow(row) {
+  const operationId = numberValue3(row.operationId);
+  const repoName = stringValue6(row.repoName);
+  const servicePath = stringValue6(row.servicePath);
+  const operationPath = stringValue6(row.operationPath);
+  const operationName = stringValue6(row.operationName);
+  if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName) return [];
+  return [{
+    operationId,
+    repoId: numberValue3(row.repoId),
+    repoName,
+    packageName: stringValue6(row.packageName),
+    serviceName: stringValue6(row.serviceName) ?? "",
+    qualifiedName: stringValue6(row.qualifiedName) ?? "",
+    servicePath,
+    operationPath,
+    operationName,
+    sourceFile: stringValue6(row.sourceFile) ?? "",
+    sourceLine: numberValue3(row.sourceLine) ?? 0,
+    score: 0.2,
+    reasons: ["operation_path_match"]
+  }];
+}
+function buildCandidates(db, targets, references, inputs) {
+  return targets.map((target) => {
+    const state = emptyCandidate(target, inputs);
+    applyDirectSignal(state, inputs, "operationPath", target.operationPath, 0.25);
+    applyDirectSignal(state, inputs, "servicePath", target.servicePath, 0.35);
+    const matchingReferences = references.filter((reference) => reference.servicePath === target.servicePath);
+    applyReferenceSignal(state, inputs, matchingReferences, "alias");
+    applyReferenceSignal(state, inputs, matchingReferences, "destination");
+    if (hasResolvedImplementation(db, target.operationId))
+      addScore(state, 0.1, "implementation_edge_resolved");
+    return state;
+  });
+}
+function emptyCandidate(target, inputs) {
+  return {
+    candidateOperationId: target.operationId,
+    repoId: target.repoId,
+    repoName: target.repoName,
+    packageName: target.packageName ?? void 0,
+    serviceName: target.serviceName,
+    qualifiedName: target.qualifiedName,
+    servicePath: target.servicePath,
+    operationPath: target.operationPath,
+    operationName: target.operationName,
+    sourceFile: target.sourceFile,
+    sourceLine: target.sourceLine,
+    originalTemplates: inputs.original,
+    effectiveValues: inputs.effective,
+    requiredVariables: inputs.required,
+    requiredVariableSources: inputs.requiredSources,
+    suppliedVariables: inputs.supplied,
+    completeVariables: { ...inputs.supplied },
+    derivedVariables: {},
+    derivedVariableSources: {},
+    derivationProvenance: {},
+    missingVariables: [],
+    conflicts: [],
+    score: Math.max(0.2, Number(target.score ?? 0)),
+    explicitSignalStrength: 0,
+    reasons: nonEmptyStrings(target.reasons, ["operation_path_match"]),
+    rejectedReasons: [],
+    inferenceBlockReasons: [],
+    viable: true,
+    rejected: false,
+    selected: false,
+    exploratory: false
+  };
+}
+function applyDirectSignal(state, inputs, kind, concrete, score) {
+  const effective = inputs.effective[kind];
+  const original = inputs.original[kind];
+  if (effective && !matchTemplate(effective, concrete)) {
+    reject(state, `${signalCode(kind)}_contradicts_runtime_substitution`);
+    return;
+  }
+  if (!effective) return;
+  const suppliedKeys = extractPlaceholders(original).filter((key) => inputs.supplied[key] !== void 0);
+  state.explicitSignalStrength += suppliedKeys.length;
+  const matched = matchTemplate(original, concrete) ?? {};
+  for (const [key, value] of Object.entries(matched)) {
+    addDerivation(state, key, value, {
+      sourceKind: `${signalCode(kind)}_template`,
+      value,
+      rule: "exact_template_match",
+      template: original
+    });
+  }
+  addScore(state, score, `${signalCode(kind)}_template_match`);
+}
+function applyReferenceSignal(state, inputs, references, kind) {
+  const original = inputs.original[kind];
+  const effective = inputs.effective[kind];
+  if (!original || extractPlaceholders(original).length === 0) return;
+  const values = references.flatMap((reference) => {
+    const concrete = kind === "alias" ? reference.alias : reference.destination;
+    return isConcrete(concrete) ? [{ reference, concrete }] : [];
+  });
+  if (effective && extractPlaceholders(effective).length === 0 && values.length > 0 && !values.some(({ concrete }) => concrete === effective)) {
+    reject(state, `${kind}_contradicts_runtime_substitution`);
+  }
+  let matchedSignal = false;
+  for (const { reference, concrete } of values) {
+    const matched = matchTemplate(original, concrete);
+    if (!matched) continue;
+    matchedSignal = true;
+    for (const [key, value] of Object.entries(matched)) {
+      addDerivation(
+        state,
+        key,
+        value,
+        dynamicReferenceProvenance(reference, kind, original, value)
+      );
+    }
   }
-  const missingVariables = [...missing].sort();
+  if (matchedSignal) {
+    state.explicitSignalStrength += extractPlaceholders(original).filter((key) => inputs.supplied[key] !== void 0).length;
+    addScore(state, 0.2, `${kind}_template_match`);
+  }
+}
+function applyUniqueIdentityEvidence(db, candidates, inputs) {
+  for (const derivation of uniqueIdentityDerivations(db, candidates, inputs.original)) {
+    const candidate = candidates.find((item) => item.candidateOperationId === derivation.operationId);
+    if (!candidate) continue;
+    addDerivation(candidate, derivation.key, derivation.value, derivation.provenance);
+    addScore(candidate, 0.2, "exact_identity_template_match");
+  }
+}
+function addDerivation(state, key, value, provenance) {
+  const priorProvenance = state.derivationProvenance[key] ?? [];
+  state.derivationProvenance[key] = uniqueProvenance([...priorProvenance, provenance]);
+  const supplied = state.suppliedVariables[key];
+  if (supplied !== void 0 && supplied !== value) {
+    addConflict(state, key, [supplied, value], "explicit_value_conflicts_with_derived_value");
+    return;
+  }
+  const prior = state.derivedVariables[key];
+  if (prior !== void 0 && prior !== value) {
+    addConflict(state, key, [prior, value], "conflicting_strong_derivations");
+    return;
+  }
+  if (supplied === void 0) state.derivedVariables[key] = value;
+  state.completeVariables[key] = supplied ?? value;
+  state.derivedVariableSources[key] ??= provenance;
+}
+function addConflict(state, key, values, reason) {
+  const sources = (state.derivationProvenance[key] ?? []).map((item) => item.sourceKind).sort();
+  state.conflicts.push({ key, values: [...new Set(values)].sort(), reason, sources });
+  reject(state, reason);
+}
+function uniqueProvenance(rows2) {
+  const sorted = [...rows2].sort((left, right) => left.sourceKind.localeCompare(right.sourceKind) || String(left.matchedName ?? "").localeCompare(String(right.matchedName ?? "")) || left.value.localeCompare(right.value));
+  const seen = /* @__PURE__ */ new Set();
+  return sorted.filter((row) => {
+    const key = JSON.stringify(row);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function finalizeCandidates(candidates, order) {
+  for (const candidate of candidates) {
+    candidate.missingVariables = order.filter((key) => candidate.completeVariables[key] === void 0);
+    candidate.viable = candidate.rejectedReasons.length === 0;
+    candidate.rejected = !candidate.viable;
+    if (candidate.missingVariables.length === 0 && candidate.viable)
+      addScore(candidate, 0.15, "all_runtime_variables_derived");
+    else if (candidate.missingVariables.length > 0)
+      addReason(candidate, "missing_required_runtime_variable");
+    candidate.score = Math.max(0, Math.min(1, candidate.score));
+    candidate.cli = candidate.missingVariables.length === 0 && candidate.viable ? cliFor(candidate.completeVariables, order) : void 0;
+  }
+}
+function stableRank(candidates) {
+  return [...candidates].sort((left, right) => Number(right.viable) - Number(left.viable) || right.score - left.score || right.explicitSignalStrength - left.explicitSignalStrength || left.repoName.localeCompare(right.repoName) || String(left.packageName ?? "").localeCompare(String(right.packageName ?? "")) || left.servicePath.localeCompare(right.servicePath) || left.operationPath.localeCompare(right.operationPath) || left.operationName.localeCompare(right.operationName) || left.candidateOperationId - right.candidateOperationId);
+}
+function inferenceDecision(candidates) {
+  const viable = candidates.filter((candidate) => candidate.viable);
+  const first = viable[0];
+  const second = viable[1];
+  if (!first || first.missingVariables.length > 0)
+    return { status: "unresolved", reason: "missing_required_runtime_variable" };
+  if (first.score < 0.85)
+    return { status: "unresolved", reason: "candidate_score_below_inference_threshold" };
+  const scoreGap = second ? Number((first.score - second.score).toFixed(12)) : void 0;
+  if (second && scoreGap !== void 0 && scoreGap <= 0.05) {
+    const reason = scoreGap === 0 ? "candidate_tied_with_equal_score" : "candidate_within_inference_margin";
+    for (const candidate of viable.filter((item) => first.score - item.score <= 0.05))
+      addInferenceBlock(candidate, reason);
+    return { status: "ambiguous", reason, scoreGap, requiredMargin: 0.05 };
+  }
+  return {
+    status: "resolved",
+    candidateOperationId: first.candidateOperationId,
+    inferredVariables: first.completeVariables,
+    score: first.score,
+    reasons: first.reasons
+  };
+}
+function boundedCandidate(candidate, limit) {
+  const derivationProvenance = Object.fromEntries(
+    Object.entries(candidate.derivationProvenance).sort(([left], [right]) => left.localeCompare(right)).map(([key, rows2]) => [key, rows2.slice(0, limit)])
+  );
+  const conflicts = candidate.conflicts.slice(0, limit).map((conflict) => ({
+    ...conflict,
+    sources: conflict.sources.slice(0, limit)
+  }));
+  return { ...candidate, derivationProvenance, conflicts };
+}
+function applyModeState(candidates, mode, inference) {
+  const selectedId = mode === "infer" && inference.status === "resolved" ? numberValue3(inference.candidateOperationId) : void 0;
+  for (const candidate of candidates) {
+    candidate.selected = selectedId === candidate.candidateOperationId;
+    candidate.exploratory = mode === "candidates" && candidate.viable;
+  }
+}
+function suggestedVarSets(candidates, order, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const rows2 = [];
+  for (const candidate of candidates) {
+    if (!candidate.cli || candidate.missingVariables.length > 0) continue;
+    if (seen.has(candidate.cli)) continue;
+    seen.add(candidate.cli);
+    rows2.push({ variables: orderedVariables(candidate.completeVariables, order), cli: candidate.cli });
+    if (rows2.length >= limit) break;
+  }
+  return rows2;
+}
+function hasResolvedImplementation(db, operationId) {
+  return Boolean(db.prepare(
+    "SELECT 1 FROM graph_edges WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND status='resolved' AND from_kind='operation' AND from_id=? LIMIT 1"
+  ).get(String(operationId)));
+}
+function templatesFromEvidence(evidence, phase) {
+  return {
+    servicePath: substitutionSignal(evidence, "servicePath", phase),
+    operationPath: substitutionSignal(evidence, "operationPath", phase),
+    alias: substitutionSignal(
+      evidence,
+      evidence.serviceAliasExpr !== void 0 ? "serviceAliasExpr" : "serviceAlias",
+      phase
+    ),
+    destination: substitutionSignal(evidence, "destination", phase)
+  };
+}
+function substitutionSignal(evidence, key, phase) {
+  const substitution = record(record(evidence.runtimeSubstitutions)[key]);
+  return stringValue6(substitution[phase]) ?? stringValue6(evidence[key]);
+}
+function effectiveSignal(evidence, key) {
+  return substitutionSignal(evidence, key, "effective");
+}
+function placeholderSources(templates) {
+  const sources = {};
+  for (const [kind, template] of Object.entries(templates)) {
+    if (typeof template !== "string") continue;
+    for (const key of extractPlaceholders(template))
+      sources[key] = [.../* @__PURE__ */ new Set([...sources[key] ?? [], `${kind}:${template}`])].sort();
+  }
+  return Object.fromEntries(Object.entries(sources).sort(([left], [right]) => left.localeCompare(right)));
+}
+function variableOrder(templates, required) {
+  const ordered = [
+    templates.servicePath,
+    templates.operationPath,
+    templates.alias,
+    templates.destination
+  ].flatMap((value) => extractPlaceholders(value));
+  return [.../* @__PURE__ */ new Set([...ordered, ...required])];
+}
+function matchTemplate(template, concrete) {
+  if (!template || !concrete) return void 0;
+  const keys = extractPlaceholders(template);
+  if (keys.length === 0) return template === concrete ? {} : void 0;
+  const match = new RegExp(`^${templateToPattern(template)}$`).exec(concrete);
+  if (!match) return void 0;
+  const values = {};
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    const value = match[index + 1];
+    if (!key || value === void 0) return void 0;
+    if (values[key] !== void 0 && values[key] !== value) return void 0;
+    values[key] = value;
+  }
+  return values;
+}
+function templateToPattern(template) {
+  let pattern = "";
+  let lastIndex = 0;
+  for (const match of template.matchAll(/\$\{([^}]*)\}/g)) {
+    pattern += escapeRegex2(template.slice(lastIndex, match.index));
+    pattern += "([^/]+?)";
+    lastIndex = (match.index ?? 0) + match[0].length;
+  }
+  return `${pattern}${escapeRegex2(template.slice(lastIndex))}`;
+}
+function cliFor(variables, order) {
+  return order.filter((key) => variables[key] !== void 0).map((key) => `--var ${shellArgument(`${key}=${variables[key]}`)}`).join(" ");
+}
+function shellArgument(value) {
+  return /^[A-Za-z0-9_./:=+-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function orderedVariables(variables, order) {
+  return Object.fromEntries(order.flatMap((key) => variables[key] === void 0 ? [] : [[key, variables[key]]]));
+}
+function addScore(state, amount, reason) {
+  state.score += amount;
+  addReason(state, reason);
+}
+function addReason(state, reason) {
+  if (!state.reasons.includes(reason)) state.reasons.push(reason);
+}
+function reject(state, reason) {
+  rejectReasonOnly(state, reason);
+  state.viable = false;
+  state.rejected = true;
+}
+function rejectReasonOnly(state, reason) {
+  if (!state.rejectedReasons.includes(reason)) state.rejectedReasons.push(reason);
+}
+function addInferenceBlock(state, reason) {
+  addReason(state, reason);
+  if (!state.inferenceBlockReasons.includes(reason))
+    state.inferenceBlockReasons.push(reason);
+}
+function requiredSuppliedVariables(inputs) {
+  return Object.fromEntries(inputs.required.flatMap((key) => inputs.supplied[key] === void 0 ? [] : [[key, inputs.supplied[key]]]));
+}
+function signalCode(kind) {
+  return kind === "servicePath" ? "service_path" : "operation_path";
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringRecord(value) {
+  const entries = Object.entries(record(value)).filter((entry) => typeof entry[1] === "string").sort(([left], [right]) => left.localeCompare(right));
+  return Object.fromEntries(entries);
+}
+function stringValue6(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function nonEmptyStrings(value, fallback) {
+  const values = stringArray(value).filter((item) => item.length > 0);
+  return values.length > 0 ? values : fallback;
+}
+function isConcrete(value) {
+  return typeof value === "string" && value.length > 0 && extractPlaceholders(value).length === 0;
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/trace/evidence.ts
+function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
+  const evidence = { ...persistedEvidence, ...contextualEvidence ?? {} };
+  return {
+    ...evidence,
+    graphEdgeId: row.id,
+    persistedGraphEdgeId: row.id > 0 ? row.id : void 0,
+    outboundCallId: call.id,
+    callSite: { sourceFile: call.source_file, sourceLine: call.source_line },
+    callType: call.call_type,
+    repoId: call.repo_id,
+    sourceFile: call.source_file,
+    sourceLine: call.source_line,
+    file: call.source_file,
+    line: call.source_line,
+    persistedTarget: { kind: row.to_kind, id: row.to_id },
+    contextualResolutionParticipated: Boolean(contextualEvidence?.contextualServiceBindingAttempted),
+    persistedResolution: persistedResolution(row)
+  };
+}
+function runtimeResolution(db, row, evidence, options, workspaceId, contextualUnresolvedReason) {
+  const dynamicMode = options.dynamicMode ?? "strict";
+  const candidateCap = positiveCandidateCap(options.maxDynamicCandidates);
+  if (!isDynamicRemoteOperationEdge(row, evidence))
+    return unchangedRuntimeResolution(
+      row,
+      boundDynamicEvidence(evidence, candidateCap),
+      contextualUnresolvedReason
+    );
+  const substituted = evidenceWithRuntimeVariables(evidence, options.vars);
+  const analysis = analyzeDynamicTargetCandidates(
+    db,
+    substituted,
+    workspaceId,
+    dynamicMode,
+    candidateCap
+  );
+  const enriched = boundDynamicEvidence(
+    analysis ? evidenceWithDynamicAnalysis(substituted, analysis) : substituted,
+    candidateCap
+  );
+  if (analysis && analysis.candidateCount > 0 && analysis.viableCandidateCount === 0 && Object.keys(analysis.appliedSuppliedVariables).length > 0)
+    return noCandidateRuntimeResolution(row, enriched);
+  if (dynamicMode === "infer") {
+    const inferred = inferredTarget(analysis);
+    if (inferred)
+      return resolvedRuntimeResolution(row, enriched, inferred, inferred.reasons);
+  }
+  if (!hasApplicableRuntimeVariables(evidence, options.vars)) {
+    const unresolvedReason2 = contextualUnresolvedReason ?? row.unresolved_reason;
+    const withSections = withEffectiveResolution(enriched, row, unresolvedReason2);
+    return { row, evidence: withSections, unresolvedReason: unresolvedReason2 };
+  }
+  const resolution = resolveRuntimeOperation(db, enriched, workspaceId);
+  if (resolution.target)
+    return resolvedRuntimeResolution(
+      row,
+      enriched,
+      resolution.target,
+      resolution.reasons
+    );
+  if (analysis && analysis.viableCandidateCount === 0 && Object.keys(analysis.appliedSuppliedVariables).length > 0)
+    return noCandidateRuntimeResolution(row, enriched);
+  const unresolvedReason = runtimeUnresolvedReason(resolution);
+  return { row, evidence: withEffectiveResolution(enriched, row, unresolvedReason, resolution), unresolvedReason };
+}
+function unchangedRuntimeResolution(row, evidence, contextualUnresolvedReason) {
+  const unresolvedReason = contextualUnresolvedReason ?? row.unresolved_reason;
+  return {
+    row,
+    evidence: withEffectiveResolution(evidence, row, unresolvedReason),
+    unresolvedReason
+  };
+}
+function noCandidateRuntimeResolution(row, evidence) {
+  const unresolvedReason = "No candidate remained after runtime substitution";
+  return {
+    row,
+    evidence: withEffectiveResolution(evidence, row, unresolvedReason),
+    unresolvedReason
+  };
+}
+function resolvedRuntimeResolution(row, evidence, target, reasons) {
+  const resolvedRow = {
+    ...row,
+    status: "resolved",
+    to_kind: "operation",
+    to_id: String(target.operationId),
+    unresolved_reason: void 0,
+    confidence: Math.max(0, Math.min(1, target.score))
+  };
+  const resolution = {
+    status: "resolved",
+    target,
+    candidates: [],
+    reasons
+  };
+  return {
+    row: resolvedRow,
+    evidence: withEffectiveResolution(evidence, resolvedRow, void 0, resolution),
+    target
+  };
+}
+function runtimeVariableDiagnostic(edges) {
+  const totals = runtimeDiagnosticTotals(edges);
+  const missingVariables = [...totals.missing].sort();
   if (missingVariables.length === 0) return void 0;
+  const shownSuggestions = totals.candidateSuggestions.slice(0, totals.maxCandidates);
+  const shownRejected = totals.rejectedCandidates.slice(0, totals.maxCandidates);
+  const shownCandidateCount = shownSuggestions.length;
   return {
     severity: "warning",
     code: "trace_runtime_variables_missing",
     message: `Runtime variables are required to resolve dynamic trace targets: ${missingVariables.join(", ")}`,
     missingVariables,
-    suggestions: missingVariables.map((key) => `--var ${key}=<value>`)
+    suggestions: missingVariables.map((key) => `--var ${key}=<value>`),
+    candidateCount: totals.candidateCount,
+    viableCandidateCount: totals.viableCandidateCount,
+    rejectedCandidateCount: totals.rejectedCandidateCount,
+    shownCandidateCount,
+    omittedCandidateCount: Math.max(0, totals.viableCandidateCount - shownCandidateCount),
+    maxDynamicCandidates: totals.maxCandidates,
+    shownRejectedCandidateCount: shownRejected.length,
+    omittedRejectedCandidateCount: Math.max(0, totals.rejectedCandidateCount - shownRejected.length),
+    candidateSuggestions: shownSuggestions,
+    rejectedCandidates: shownRejected,
+    suggestedVarSets: uniqueCliRows(totals.suggestedVarSets).slice(0, totals.maxCandidates),
+    copyableExamples: copyableExamples(totals.suggestedVarSets, totals.candidateCount, totals.maxCandidates)
+  };
+}
+function runtimeDiagnosticTotals(edges) {
+  const missing = /* @__PURE__ */ new Set();
+  let candidateCount = 0;
+  let viableCandidateCount = 0;
+  let rejectedCandidateCount = 0;
+  let maxCandidates = 5;
+  const candidateSuggestions = [];
+  const rejectedCandidates = [];
+  const suggestedVarSets2 = [];
+  for (const edge of edges) {
+    const effective = parseObject(edge.evidence.effectiveResolution);
+    if (!["dynamic", "unresolved", "ambiguous"].includes(String(effective.status ?? "")))
+      continue;
+    const substitutions = edge.evidence.runtimeSubstitutions;
+    if (!substitutions || typeof substitutions !== "object" || Array.isArray(substitutions)) continue;
+    for (const value of Object.values(substitutions))
+      for (const key of value.missing ?? []) missing.add(key);
+    const exploration = parseObject(edge.evidence.dynamicTargetExploration);
+    maxCandidates = positiveCandidateCap(numeric(exploration.maxCandidates) || maxCandidates);
+    candidateCount += numeric(exploration.candidateCount);
+    viableCandidateCount += numeric(exploration.viableCandidateCount);
+    rejectedCandidateCount += numeric(exploration.rejectedCandidateCount);
+    appendBounded(
+      candidateSuggestions,
+      recordArray(edge.evidence.dynamicTargetCandidateSuggestions),
+      maxCandidates
+    );
+    appendBounded(
+      rejectedCandidates,
+      recordArray(exploration.rejectedCandidates),
+      maxCandidates
+    );
+    appendBounded(
+      suggestedVarSets2,
+      recordArray(exploration.suggestedVarSets),
+      maxCandidates
+    );
+  }
+  return {
+    missing,
+    candidateCount,
+    viableCandidateCount,
+    rejectedCandidateCount,
+    maxCandidates,
+    candidateSuggestions,
+    rejectedCandidates,
+    suggestedVarSets: suggestedVarSets2
   };
 }
+function runtimeNoCandidateDiagnostics(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  return edges.flatMap((edge) => {
+    const exploration = parseObject(edge.evidence.dynamicTargetExploration);
+    const suppliedVariables = parseObject(exploration.suppliedVariables);
+    const appliedSuppliedVariables = parseObject(
+      exploration.appliedSuppliedVariables
+    );
+    if (numeric(exploration.viableCandidateCount) !== 0 || Object.keys(appliedSuppliedVariables).length === 0) return [];
+    const callSite = parseObject(edge.evidence.callSite);
+    const key = JSON.stringify([callSite, suppliedVariables]);
+    if (seen.has(key)) return [];
+    seen.add(key);
+    const maxCandidates = positiveCandidateCap(numeric(exploration.maxCandidates));
+    return [{
+      severity: "warning",
+      code: "no_candidate_after_runtime_substitution",
+      message: "No dynamic target candidate remained after applying runtime variables",
+      suppliedVariables,
+      appliedSuppliedVariables,
+      substitutedSignals: parseObject(exploration.substitutedSignals),
+      candidateCount: numeric(exploration.candidateCount),
+      viableCandidateCount: 0,
+      rejectedCandidateCount: numeric(exploration.rejectedCandidateCount),
+      shownCandidateCount: numeric(exploration.shownCandidateCount),
+      omittedCandidateCount: numeric(exploration.omittedCandidateCount),
+      shownRejectedCandidateCount: numeric(
+        exploration.shownRejectedCandidateCount
+      ),
+      omittedRejectedCandidateCount: numeric(
+        exploration.omittedRejectedCandidateCount
+      ),
+      rejectedCandidates: recordArray(exploration.rejectedCandidates).slice(0, maxCandidates),
+      callSite
+    }];
+  });
+}
 function edgeTarget(row, evidence) {
   const effective = parseObject(evidence.effectiveResolution);
-  const targetServicePath = stringValue4(effective.targetServicePath ?? evidence.targetServicePath);
-  const targetOperationPath = stringValue4(effective.targetOperationPath ?? evidence.targetOperationPath);
+  const targetServicePath = stringValue7(effective.targetServicePath ?? evidence.targetServicePath);
+  const targetOperationPath = stringValue7(effective.targetOperationPath ?? evidence.targetOperationPath);
   if (targetServicePath && targetOperationPath) return `${targetServicePath}${targetOperationPath}`;
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath) return `${runtimeCandidate.servicePath}${runtimeCandidate.operationPath}`;
-  const servicePath = stringValue4(evidence.servicePath);
-  const operationPath = stringValue4(evidence.operationPath);
-  const targetOperation = stringValue4(evidence.targetOperation);
-  const targetRepo = stringValue4(evidence.targetRepo) ?? "";
+  const servicePath = stringValue7(evidence.servicePath);
+  const operationPath = stringValue7(evidence.operationPath);
+  const targetOperation = stringValue7(evidence.targetOperation);
+  const targetRepo = stringValue7(evidence.targetRepo) ?? "";
   if (row.edge_type === "HANDLER_RUNS_DB_QUERY") return `Entity: ${row.to_id || "unknown"}`;
-  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue4(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
+  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue7(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
   if (row.edge_type === "HANDLER_CALLS_EXTERNAL_HTTP") {
     const target = parseObject(evidence.externalTarget);
-    return stringValue4(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
+    return stringValue7(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
   }
   if (servicePath && operationPath) return `${servicePath}${operationPath}`;
   return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
@@ -3750,23 +5830,102 @@ function withEffectiveResolution(evidence, row, unresolvedReason, resolution) {
   return { ...rest, effectiveResolution: current, linker: { status: current.status, confidence: current.confidence, reason: unresolvedReason, edgeType: current.edgeType } };
 }
 function resolveRuntimeOperation(db, evidence, workspaceId) {
-  const servicePath = stringValue4(evidence.servicePath);
-  const rawOperationPath = stringValue4(evidence.operationPath);
+  const servicePath = stringValue7(evidence.servicePath);
+  const rawOperationPath = stringValue7(evidence.operationPath);
   const normalized = normalizeODataOperationInvocationPath(rawOperationPath);
-  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue4(evidence.normalizedOperationPath) ?? rawOperationPath;
-  const alias = stringValue4(evidence.serviceAliasExpr ?? evidence.serviceAlias);
-  const destination = stringValue4(evidence.destination);
+  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue7(evidence.normalizedOperationPath) ?? rawOperationPath;
+  const alias = stringValue7(evidence.serviceAliasExpr ?? evidence.serviceAlias);
+  const destination = stringValue7(evidence.destination);
   return resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: true }, workspaceId);
 }
 function evidenceWithRuntimeVariables(evidence, vars) {
   const substitutions = runtimeSubstitutions(evidence, vars ?? {});
-  const next = { ...evidence, runtimeSubstitutions: substitutions };
+  const suppliedRuntimeVariables = Object.fromEntries(
+    Object.entries(vars ?? {}).sort(([left], [right]) => left.localeCompare(right))
+  );
+  const next = {
+    ...evidence,
+    runtimeSubstitutions: substitutions,
+    suppliedRuntimeVariables
+  };
   for (const [key, value] of Object.entries(substitutions)) if (value.effective) next[key] = value.effective;
   const missing = Object.values(substitutions).flatMap((value) => value.missing);
   if (missing.length > 0) next.missingRuntimeVariables = [...new Set(missing)].sort();
-  if (Object.keys(vars ?? {}).length > 0) next.runtimeVariablesApplied = true;
+  if (Object.keys(suppliedRuntimeVariables).length > 0) next.runtimeVariablesApplied = true;
   return next;
 }
+function evidenceWithDynamicAnalysis(evidence, analysis) {
+  const persistedCandidates = recordArray(evidence.candidates);
+  const persistedScores = recordArray(evidence.candidateScores);
+  return {
+    ...evidence,
+    candidates: persistedCandidates.slice(0, analysis.maxCandidates),
+    candidateScores: persistedScores.slice(0, analysis.maxCandidates),
+    persistedCandidateCount: persistedCandidates.length,
+    persistedCandidateOmittedCount: Math.max(
+      0,
+      persistedCandidates.length - analysis.maxCandidates
+    ),
+    dynamicTargetExploration: {
+      mode: analysis.mode,
+      maxCandidates: analysis.maxCandidates,
+      missingVariables: analysis.missingVariables,
+      requiredVariables: analysis.requiredVariables,
+      suppliedVariables: analysis.suppliedVariables,
+      appliedSuppliedVariables: analysis.appliedSuppliedVariables,
+      substitutedSignals: analysis.substitutedSignals,
+      candidateCount: analysis.candidateCount,
+      viableCandidateCount: analysis.viableCandidateCount,
+      rejectedCandidateCount: analysis.rejectedCandidateCount,
+      shownCandidateCount: analysis.shownCandidateCount,
+      omittedCandidateCount: analysis.omittedCandidateCount,
+      shownRejectedCandidateCount: analysis.shownRejectedCandidateCount,
+      omittedRejectedCandidateCount: analysis.omittedRejectedCandidateCount,
+      rejectedCandidates: analysis.rejectedCandidates,
+      suggestedVarSets: analysis.suggestedVarSets
+    },
+    dynamicTargetCandidates: analysis.candidates,
+    dynamicTargetCandidateSuggestions: analysis.shownCandidates,
+    rejectedCandidates: analysis.rejectedCandidates,
+    dynamicTargetInference: analysis.inference
+  };
+}
+var boundedDynamicListKeys = /* @__PURE__ */ new Set([
+  "candidates",
+  "candidateScores",
+  "dynamicTargetCandidates",
+  "dynamicTargetCandidateSuggestions",
+  "candidateSuggestions",
+  "suggestedVarSets",
+  "rejectedCandidates",
+  "rejectedCandidateSuggestions",
+  "copyableExamples",
+  "conflicts"
+]);
+function boundDynamicEvidence(evidence, limit) {
+  const candidateCount = numeric(evidence.persistedCandidateCount) || (Array.isArray(evidence.candidates) ? evidence.candidates.length : 0);
+  const projected = boundDynamicValue(evidence, limit);
+  const next = parseObject(projected);
+  if (candidateCount === 0) return next;
+  return {
+    ...next,
+    persistedCandidateCount: candidateCount,
+    persistedCandidateOmittedCount: Math.max(0, candidateCount - limit)
+  };
+}
+function boundDynamicValue(value, limit, key, parentKey) {
+  if (Array.isArray(value)) {
+    const bounded = Boolean(key && (boundedDynamicListKeys.has(key) || parentKey === "derivationProvenance" || parentKey === "conflicts" && key === "sources"));
+    const input = bounded ? value.slice(0, limit) : value;
+    const projected = input.map((item) => boundDynamicValue(item, limit, void 0, key ?? parentKey));
+    return projected;
+  }
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [
+    childKey,
+    boundDynamicValue(child, limit, childKey, key ?? parentKey)
+  ]));
+}
 function runtimeSubstitutions(evidence, vars) {
   const substitutions = {};
   for (const key of ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"]) {
@@ -3776,17 +5935,44 @@ function runtimeSubstitutions(evidence, vars) {
   return substitutions;
 }
 function substitutionValue(evidence, key) {
-  const value = stringValue4(evidence[key]);
+  const value = stringValue7(evidence[key]);
   if (key !== "operationPath") return value;
   const normalized = normalizeODataOperationInvocationPath(value);
   return normalized?.wasInvocation ? normalized.normalizedOperationPath : value;
 }
-function isRemoteRuntimeCandidate(row, evidence, vars) {
-  if (!vars || Object.keys(vars).length === 0) return false;
+function isDynamicRemoteOperationEdge(row, evidence) {
+  if (evidence.callType !== "remote_action") return false;
   if (!["dynamic", "ambiguous", "unresolved"].includes(String(row.status ?? ""))) return false;
-  if (!["DYNAMIC_EDGE_CANDIDATE", "UNRESOLVED_EDGE", "REMOTE_CALL_RESOLVES_TO_OPERATION"].includes(row.edge_type)) return false;
+  return ["DYNAMIC_EDGE_CANDIDATE", "UNRESOLVED_EDGE", "REMOTE_CALL_RESOLVES_TO_OPERATION"].includes(row.edge_type);
+}
+function hasApplicableRuntimeVariables(evidence, vars) {
+  if (!vars || Object.keys(vars).length === 0) return false;
   return ["servicePath", "operationPath", "serviceAliasExpr", "serviceAlias", "destination"].some((key) => hasRuntimeVariable(evidence[key], vars));
 }
+function inferredTarget(analysis) {
+  if (analysis?.inference.status !== "resolved") return void 0;
+  const id = Number(analysis.inference.candidateOperationId);
+  const candidate = analysis.candidates.find((item) => item.candidateOperationId === id);
+  if (!candidate) return void 0;
+  return targetFromCandidate(candidate);
+}
+function targetFromCandidate(candidate) {
+  return {
+    operationId: candidate.candidateOperationId,
+    repoName: candidate.repoName,
+    serviceName: "",
+    qualifiedName: "",
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    operationName: candidate.operationName,
+    repoId: candidate.repoId,
+    packageName: candidate.packageName,
+    score: candidate.score,
+    reasons: candidate.reasons,
+    sourceFile: candidate.sourceFile,
+    sourceLine: candidate.sourceLine
+  };
+}
 function hasRuntimeVariable(value, vars) {
   return typeof value === "string" && extractPlaceholders(value).some((key) => Object.hasOwn(vars, key));
 }
@@ -3798,25 +5984,118 @@ function runtimeUnresolvedReason(resolution) {
 function parseObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue4(value) {
+function stringValue7(value) {
   return typeof value === "string" ? value : void 0;
 }
+function numeric(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+}
+function appendBounded(target, values, limit) {
+  const remaining = Math.max(0, limit - target.length);
+  if (remaining > 0) target.push(...values.slice(0, remaining));
+}
+function uniqueCliRows(rows2) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows2.filter((row) => {
+    const cli = typeof row.cli === "string" ? row.cli : JSON.stringify(row);
+    if (seen.has(cli)) return false;
+    seen.add(cli);
+    return true;
+  });
+}
+function copyableExamples(suggestedVarSets2, candidateCount, limit) {
+  const variableExamples = uniqueCliRows(suggestedVarSets2).flatMap((row) => typeof row.cli === "string" ? [row.cli] : []);
+  const exploration = candidateCount > 0 ? ["--dynamic-mode candidates --max-dynamic-candidates 20"] : [];
+  return [...variableExamples, ...exploration].slice(0, limit);
+}
+function positiveCandidateCap(value) {
+  return Number.isFinite(value) && Number(value) > 0 ? Math.floor(Number(value)) : 5;
+}
+
+// src/trace/dynamic-branches.ts
+function dynamicCandidateBranches(depth, call, evidence) {
+  const exploration = objectRecord(evidence.dynamicTargetExploration);
+  return recordArray2(evidence.dynamicTargetCandidateSuggestions).map((candidate) => ({
+    step: depth,
+    type: "dynamic_candidate_branch",
+    from: `${call.repoName}:${call.source_file}:${call.source_line}`,
+    to: `${String(candidate.servicePath ?? "")}${String(candidate.operationPath ?? "")}`,
+    evidence: {
+      ...candidate,
+      exploratory: true,
+      dynamicMode: String(exploration.mode ?? "candidates"),
+      selected: false,
+      omittedCandidateCount: numericValue2(exploration.omittedCandidateCount)
+    },
+    confidence: numericValue2(candidate.score),
+    unresolvedReason: "Exploratory dynamic target candidate; provide runtime variables to select it"
+  }));
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function recordArray2(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+}
+function numericValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/trace/002-trace-diagnostics.ts
+function loadTraceDiagnostics(db, repoId, includeWorkspaceDiagnostics, workspaceId) {
+  if (repoId === void 0 && !includeWorkspaceDiagnostics) return [];
+  return db.prepare(`SELECT d.repo_id repoId,d.severity,d.code,d.message,
+      d.source_file sourceFile,d.source_line sourceLine
+    FROM diagnostics d LEFT JOIN repositories r ON r.id=d.repo_id
+    WHERE (? IS NULL OR d.repo_id=?)
+      AND (? IS NULL OR d.repo_id IS NULL OR r.workspace_id=?)
+    ORDER BY severity,code,COALESCE(source_file,''),
+      COALESCE(source_line,0),d.id`).all(
+    repoId,
+    repoId,
+    workspaceId,
+    workspaceId
+  );
+}
+function prependTraceDiagnostic(diagnostics, diagnostic) {
+  const duplicate = diagnostics.findIndex((item) => sameDiagnosticLocation(item, diagnostic));
+  if (duplicate >= 0) diagnostics.splice(duplicate, 1);
+  diagnostics.unshift(diagnostic);
+}
+function sameDiagnosticLocation(left, right) {
+  if (left.code !== right.code) return false;
+  const leftFile = stringValue8(left.sourceFile);
+  const rightFile = stringValue8(right.sourceFile);
+  if (leftFile || rightFile)
+    return leftFile === rightFile && numericValue3(left.sourceLine) === numericValue3(right.sourceLine);
+  return String(left.message ?? "") === String(right.message ?? "");
+}
+function stringValue8(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numericValue3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 
 // src/trace/trace-engine.ts
-function normalizeOperation(value) {
+function normalizeOperation2(value) {
   if (!value) return void 0;
   return value.startsWith("/") ? value.slice(1) : value;
 }
 function positiveDepth(value) {
   return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
 }
-function operationStartScope(db, repoId, start, hintOptions) {
-  const requested = normalizeOperation(start.operationPath ?? start.operation);
+function operationStartScope(db, repoId, start, hintOptions, workspaceId) {
+  const requested = normalizeOperation2(start.operationPath ?? start.operation);
   if (!requested) return void 0;
   const rows2 = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.service_path servicePath,r.id repoId,r.name repoName
     FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
-    WHERE (? IS NULL OR r.id=?) AND (? IS NULL OR s.service_path=?) AND (o.operation_name=? OR o.operation_path=? OR o.operation_path=?)
-    ORDER BY r.name,s.service_path,o.operation_name,o.id`).all(repoId, repoId, start.servicePath, start.servicePath, requested, requested, requested.startsWith("/") ? requested : `/${requested}`);
+    WHERE (? IS NULL OR r.workspace_id=?) AND (? IS NULL OR r.id=?)
+      AND (? IS NULL OR s.service_path=?) AND (o.operation_name=? OR o.operation_path=? OR o.operation_path=?)
+    ORDER BY r.name,s.service_path,o.operation_name,o.id`).all(workspaceId, workspaceId, repoId, repoId, start.servicePath, start.servicePath, requested, requested, requested.startsWith("/") ? requested : `/${requested}`);
   if (rows2.length === 0) return void 0;
   const repoCount = new Set(rows2.map((row) => String(row.repoName))).size;
   const serviceCount = new Set(rows2.map((row) => `${String(row.repoName)}:${String(row.servicePath)}`)).size;
@@ -3847,54 +6126,34 @@ function implementationRejectionReasons(evidence) {
   const reasons = candidates.flatMap((candidate) => Array.isArray(candidate.rejectedReasons) ? candidate.rejectedReasons.filter((reason) => typeof reason === "string") : []);
   return [...new Set(reasons)].sort();
 }
-function sourceFilesForStart(db, repoId, start) {
-  const handler = start.handler;
-  const operation = normalizeOperation(start.operation ?? start.operationPath);
-  if (!handler && !operation) return void 0;
-  const rows2 = db.prepare(
-    `SELECT DISTINCT hc.source_file sourceFile,s.id symbolId
-       FROM handler_classes hc LEFT JOIN handler_methods hm ON hm.handler_class_id=hc.id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.name=hm.method_name
-       WHERE (? IS NULL OR hc.repo_id=?) AND (? IS NULL OR hc.class_name=? OR hm.method_name=?)
-         AND (? IS NULL OR hm.decorator_value=? OR hm.method_name=?)
-         AND (? IS NULL OR EXISTS (SELECT 1 FROM cds_services s JOIN cds_operations o ON o.service_id=s.id WHERE s.repo_id=hc.repo_id AND s.service_path=? AND (? IS NULL OR o.operation_path=? OR o.operation_name=? OR hm.decorator_value=? OR hm.method_name=?)))`
-  ).all(
-    repoId,
-    repoId,
-    handler,
-    handler,
-    handler,
-    operation,
-    operation,
-    operation,
-    start.servicePath,
-    start.servicePath,
-    operation,
-    operation,
-    operation,
-    operation,
-    operation
+function sourceFilesForStart(db, repoId, start, workspaceId) {
+  return sourceScopeForSelector(db, repoId, start, workspaceId);
+}
+function startScope(db, start, hintOptions, workspaceId) {
+  const repos = start.repo ? reposByName(db, start.repo, workspaceId).map((row) => ({
+    id: row.id,
+    name: row.name,
+    packageName: row.package_name ?? void 0
+  })) : [];
+  if (start.repo && repos.length === 0) return {
+    selectorMatched: false,
+    startDiagnostics: [selectorRepoNotFoundDiagnostic(start.repo)]
+  };
+  if (start.repo && repos.length > 1) return {
+    selectorMatched: false,
+    startDiagnostics: [selectorRepoAmbiguousDiagnostic(start.repo, repos)]
+  };
+  const repo = repos[0];
+  const operationScope = operationStartScope(
+    db,
+    repo?.id,
+    start,
+    hintOptions,
+    workspaceId
   );
-  if (rows2.length > 0) return { files: new Set(rows2.map((row) => row.sourceFile).filter(Boolean)), symbols: new Set(rows2.map((row) => Number(row.symbolId)).filter(Boolean)), repoId };
-  if (start.servicePath && operation) {
-    const implRows = db.prepare(`SELECT DISTINCT hc.source_file sourceFile,sym.id symbolId
-      FROM cds_services s JOIN cds_operations o ON o.service_id=s.id
-      JOIN graph_edges e ON e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND e.status='resolved' AND e.from_kind='operation' AND e.from_id=CAST(o.id AS TEXT)
-      JOIN handler_methods hm ON hm.id=CAST(e.to_id AS INTEGER)
-      JOIN handler_classes hc ON hc.id=hm.handler_class_id
-      LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id AND sym.source_file=hc.source_file AND sym.name=hm.method_name
-      WHERE (? IS NULL OR s.repo_id=?) AND s.service_path=? AND (o.operation_path=? OR o.operation_name=?)`).all(repoId, repoId, start.servicePath, operation, operation);
-    if (implRows.length > 0) return { files: new Set(implRows.map((row) => row.sourceFile).filter(Boolean)), symbols: new Set(implRows.map((row) => Number(row.symbolId)).filter(Boolean)), repoId };
-  }
-  return void 0;
-}
-function startScope(db, start, hintOptions) {
-  const repo = start.repo ? db.prepare(
-    "SELECT id,name FROM repositories WHERE name=? OR package_name=?"
-  ).get(start.repo, start.repo) : void 0;
-  if (start.repo && !repo) return { repo, selectorMatched: false };
-  const operationScope = operationStartScope(db, repo?.id, start, hintOptions);
   const terminalOperationScope = operationScope && !operationScope.files && (operationScope.diagnostics ?? []).some((d) => d.resolutionStage === "operation" || d.resolutionStage === "implementation");
-  const sourceScope = operationScope?.files || terminalOperationScope ? operationScope : sourceFilesForStart(db, repo?.id, start);
+  const sourceScope = operationScope?.files || terminalOperationScope ? operationScope : sourceFilesForStart(db, repo?.id, start, workspaceId);
+  const terminalSelectorScope = Boolean(sourceScope?.diagnostics?.length && !sourceScope.files);
   const sourceFiles = sourceScope?.files;
   const hasSelector = Boolean(
     start.handler ?? start.operation ?? start.operationPath ?? start.servicePath
@@ -3906,9 +6165,9 @@ function startScope(db, start, hintOptions) {
     executionRepoId: sourceScope?.repoId ?? repo?.id,
     sourceFiles,
     symbolIds: sourceScope?.symbols,
-    selectorMatched: !terminalOperationScope && (!hasSelector || sourceFiles !== void 0),
+    selectorMatched: !terminalOperationScope && !terminalSelectorScope && (!hasSelector || sourceFiles !== void 0),
     startOperationId: operationScope?.operationId,
-    startDiagnostics: operationScope?.diagnostics
+    startDiagnostics: operationScope?.diagnostics?.length ? operationScope.diagnostics : sourceScope?.diagnostics
   };
 }
 function handlerFilesForOperation(db, operationId) {
@@ -3917,12 +6176,23 @@ function handlerFilesForOperation(db, operationId) {
     FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?`
   ).get(operationId);
   if (!op) return /* @__PURE__ */ new Set();
-  const operation = normalizeOperation(op.operationPath ?? op.operationName);
+  const operation = normalizeOperation2(op.operationPath ?? op.operationName);
   const rows2 = db.prepare(
     `SELECT DISTINCT hc.source_file sourceFile,sym.id symbolId FROM handler_classes hc
     JOIN handler_methods hm ON hm.handler_class_id=hc.id
-    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id AND sym.source_file=hc.source_file AND sym.name=hm.method_name
-    WHERE hc.repo_id=? AND (hm.decorator_value=? OR hm.method_name=? OR hm.decorator_value=?)`
+    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
+      AND sym.source_file=hc.source_file
+      AND sym.qualified_name=hc.class_name || '.' || hm.method_name
+      AND sym.start_line=hm.source_line
+    WHERE hc.repo_id=?
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
+        CASE WHEN hm.decorator_kind='Event' THEN 'event'
+          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
+          ELSE 'unsupported' END)='operation'
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
+          THEN 1 ELSE 0 END)=1
+      AND (hm.decorator_value=? OR hm.method_name=? OR hm.decorator_value=?)`
   ).all(op.repoId, operation, operation, op.operationName);
   return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
 }
@@ -3937,7 +6207,9 @@ function handlerMethodNode(db, methodId) {
 function implementationScope(db, operationId) {
   const edge = implementationEdge(db, operationId);
   if (!edge || edge.status !== "resolved") return { files: /* @__PURE__ */ new Set(), edge };
-  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.name=hm.method_name WHERE hm.id=?").get(edge.to_id);
+  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.qualified_name=hc.class_name || '.' || hm.method_name AND s.start_line=hm.source_line WHERE hm.id=?").get(edge.to_id);
+  if (!row || typeof row.symbolId !== "number")
+    return { repoId: row?.repoId, files: /* @__PURE__ */ new Set(), edge };
   return { repoId: row?.repoId, files: new Set(row?.sourceFile ? [row.sourceFile] : []), symbolId: row?.symbolId, edge };
 }
 function implementationMethodIdFromHint(edge, options) {
@@ -3973,8 +6245,8 @@ function contextImplementationMethodId(edge, callerRepoId, remoteEvidence, hintO
   return { blocksAutomatic: false, evidence: hinted.evidence.reason === "no_scoped_hint_matched_edge" ? hinted.evidence : { status: "tied", tieReason: scores.length > 1 ? "duplicate_helper_implementation_candidates" : "no_unique_materially_stronger_candidate", candidateScores: scores } };
 }
 function handlerScope(db, methodId) {
-  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.name=hm.method_name WHERE hm.id=?").get(methodId);
-  if (!row) return void 0;
+  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.qualified_name=hc.class_name || '.' || hm.method_name AND s.start_line=hm.source_line WHERE hm.id=?").get(methodId);
+  if (!row || typeof row.symbolId !== "number") return void 0;
   return { repoId: row.repoId, files: new Set(row.sourceFile ? [row.sourceFile] : []), symbolId: row.symbolId };
 }
 function traceEdgeType(call, row) {
@@ -4181,20 +6453,22 @@ function contextualRuntimeResolution(db, call, binding, workspaceId, persistedRo
 }
 function trace(db, start, options) {
   const hintOptions = { implementationRepo: options.implementationRepo, implementationHints: options.implementationHints };
-  const scope = startScope(db, start, hintOptions);
-  const diagnostics = db.prepare(
-    "SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics WHERE (? IS NULL OR repo_id=?)"
-  ).all(scope.repo?.id, scope.repo?.id);
-  const stale = db.prepare("SELECT name,graph_stale_reason reason FROM repositories WHERE graph_stale_reason IS NOT NULL AND (? IS NULL OR id=?)").all(scope.repo?.id, scope.repo?.id);
+  const scope = startScope(db, start, hintOptions, options.workspaceId);
+  const hasSelector = Boolean(start.repo || start.handler || start.operation || start.operationPath || start.servicePath);
+  const diagnosticRepoId = scope.executionRepoId ?? scope.repo?.id;
+  const diagnostics = loadTraceDiagnostics(
+    db,
+    diagnosticRepoId,
+    !hasSelector,
+    options.workspaceId
+  );
+  const stale = diagnosticRepoId !== void 0 || !hasSelector ? db.prepare("SELECT name,graph_stale_reason reason FROM repositories WHERE graph_stale_reason IS NOT NULL AND (? IS NULL OR id=?) AND (? IS NULL OR workspace_id=?) ORDER BY name,id").all(diagnosticRepoId, diagnosticRepoId, options.workspaceId, options.workspaceId) : [];
   for (const row of stale)
-    diagnostics.unshift({ severity: "warning", code: "graph_stale", message: `Graph is stale for ${row.name ?? "repository"}: ${row.reason ?? "facts_changed"}. Run service-flow link.` });
-  for (const diagnostic of scope.startDiagnostics ?? []) diagnostics.unshift(diagnostic);
+    prependTraceDiagnostic(diagnostics, { severity: "warning", code: "graph_stale", message: `Graph is stale for ${row.name ?? "repository"}: ${row.reason ?? "facts_changed"}. Run service-flow link.` });
+  for (const diagnostic of scope.startDiagnostics ?? [])
+    prependTraceDiagnostic(diagnostics, diagnostic);
   if (!scope.selectorMatched && !scope.startDiagnostics?.length)
-    diagnostics.unshift({
-      severity: "warning",
-      code: "trace_start_not_found",
-      message: start.servicePath && !start.operation && !start.operationPath && !start.handler ? "Service-only trace requires --operation or --path and will not broaden to the whole workspace" : "No handler source matched the requested trace start selector"
-    });
+    prependTraceDiagnostic(diagnostics, selectorNotFoundDiagnostic(start));
   const maxDepth = positiveDepth(options.depth);
   const edges = [];
   const nodes = /* @__PURE__ */ new Map();
@@ -4223,8 +6497,8 @@ function trace(db, start, options) {
     if (seenScopes.has(key)) continue;
     seenScopes.add(key);
     const calls = db.prepare(
-      `SELECT c.*,r.name repoName FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE (? IS NULL OR c.repo_id=?) ORDER BY c.source_file,c.source_line`
-    ).all(current.repoId, current.repoId);
+      `SELECT c.*,r.name repoName FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE (? IS NULL OR c.repo_id=?) AND (? IS NULL OR r.workspace_id=?) ORDER BY c.source_file,c.source_line`
+    ).all(current.repoId, current.repoId, options.workspaceId, options.workspaceId);
     const filtered = calls.filter(
       (c) => (!current.symbolIds || current.symbolIds.has(Number(c.source_symbol_id))) && (!current.files || current.files.has(String(c.source_file))) && includeCall(String(c.call_type), options)
     );
@@ -4269,7 +6543,11 @@ function trace(db, start, options) {
           String(row.evidence_json || "{}")
         );
         const rawEvidence = baseTraceEvidence(row, call, persistedEvidence, contextual.evidence);
-        const effective = runtimeResolution(db, row, rawEvidence, options.vars, workspaceIdForCall(db, String(call.id)), contextual.unresolvedReason);
+        const effective = runtimeResolution(db, row, rawEvidence, {
+          vars: options.vars,
+          dynamicMode: options.dynamicMode ?? "strict",
+          maxDynamicCandidates: options.maxDynamicCandidates
+        }, workspaceIdForCall(db, String(call.id)), contextual.unresolvedReason);
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
         const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
@@ -4289,6 +6567,8 @@ function trace(db, start, options) {
           confidence: Number(effectiveRow.confidence ?? call.confidence),
           unresolvedReason: effective.unresolvedReason
         });
+        if ((options.dynamicMode ?? "strict") === "candidates")
+          edges.push(...dynamicCandidateBranches(current.depth, call, evidence));
         if (effectiveRow.to_kind === "operation") {
           const implementation = implementationScope(db, effectiveRow.to_id);
           const contextSelection = contextImplementationMethodId(implementation.edge, current.repoId, evidence, hintOptions);
@@ -4297,7 +6577,7 @@ function trace(db, start, options) {
           if (implementation.edge) {
             const implEvidence = JSON.parse(String(implementation.edge.evidence_json || "{}"));
             const hintDiagnostic = implementationHintDiagnostic(contextSelection, implEvidence.implementationHintSuggestions);
-            if (hintDiagnostic) diagnostics.unshift(hintDiagnostic);
+            if (hintDiagnostic) prependTraceDiagnostic(diagnostics, hintDiagnostic);
             const handlerNode = implementation.edge.status === "resolved" ? handlerMethodNode(db, implementation.edge.to_id) : contextNode;
             const implTo = handlerNode?.label ? String(handlerNode.label) : `${implementation.edge.to_kind}:${implementation.edge.to_id}`;
             if (handlerNode) nodes.set(String(handlerNode.id), handlerNode);
@@ -4343,16 +6623,35 @@ function trace(db, start, options) {
     }
   }
   const runtimeDiagnostic = runtimeVariableDiagnostic(edges);
-  if (runtimeDiagnostic) diagnostics.unshift(runtimeDiagnostic);
+  if (runtimeDiagnostic) prependTraceDiagnostic(diagnostics, runtimeDiagnostic);
+  for (const diagnostic of runtimeNoCandidateDiagnostics(edges))
+    prependTraceDiagnostic(diagnostics, diagnostic);
   return { start, nodes: [...nodes.values()], edges, diagnostics };
 }
 
 export {
+  upsertWorkspace,
+  getWorkspace,
+  upsertRepository,
+  listRepositories,
+  reposByName,
+  clearRepoFacts,
+  insertRequires,
+  insertService,
+  insertHandler,
+  handlerMethodIsExecutable,
+  insertRegistrations,
+  insertBindings,
+  insertExecutableSymbols,
+  insertSymbolCalls,
+  insertCalls,
   normalizePath,
   stripQuotes,
   discoverRepositories,
   parsePackageJson,
+  loadPackageJsonSnapshot,
   parseCdsFile,
+  loadRepositorySourceContext,
   parseDecorators,
   parseHandlerRegistrations,
   redactText,
@@ -4369,6 +6668,7 @@ export {
   implementationHintSuggestions,
   linkWorkspace,
   parseVars,
+  selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-52OUS3MO.js.map
+//# sourceMappingURL=chunk-PTLDSHRC.js.map