@saptools/service-flow 0.1.67 → 0.1.68

package/dist/cli.js

@@ -2,26 +2,26 @@
 import {
   ANALYZER_VERSION,
   VERSION,
+  analyzePackagePublicSurface,
+  bindingSite,
   classifyODataPathIntent,
   classifyOutboundCallsInSource,
-  clearRepoFacts,
+  collectSymbolImportBindings,
   compactTrace,
   containsSupportedOutboundCall,
+  createBindingLexicalIndex,
+  derivedMemberImportReference,
   discoverRepositories,
+  executableSymbolCandidates,
   factLifecycleDiagnostic,
-  getWorkspace,
-  handlerMethodIsExecutable,
+  identifierMatchesDeclaration,
   implementationHintSuggestions,
-  insertBindings,
   insertCalls,
-  insertExecutableSymbols,
-  insertHandler,
-  insertRegistrations,
-  insertRequires,
-  insertService,
   insertSymbolCalls,
+  lexicalIdentifierDeclaration,
+  lexicalIdentifierDeclarations,
+  lexicalScopeChain,
   linkWorkspace,
-  listRepositories,
   loadPackageJsonSnapshot,
   loadRepositorySourceContext,
   migrate,
@@ -32,17 +32,19 @@ import {
   parseHandlerRegistrations,
   parseImplementationHint,
   parseOutboundCalls,
+  parsePackageImportReference,
   parsePackageJson,
   parseServiceBindings,
   parseVars,
   projectBoundedInOrder,
   redactValue,
-  reposByName,
+  selectCallOwner,
+  selectVisibleBinding,
   selectorRepoAmbiguousDiagnostic,
-  trace,
-  upsertRepository,
-  upsertWorkspace
-} from "./chunk-ZQABU7MR.js";
+  stableLocalValueReference,
+  symbolImportReference,
+  trace
+} from "./chunk-AEM4JY22.js";
 
 // src/cli.ts
 import { Command, Option } from "commander";
@@ -209,6 +211,345 @@ function openReadOnlyDatabase(dbPath) {
   return openDatabase(dbPath, { readonly: true, migrate: false });
 }
 
+// src/db/repositories.ts
+function initialPackagePublicSurface(packageName2) {
+  return JSON.stringify({
+    schema: "service-flow/package-public-surface@1",
+    status: packageName2 ? "incomplete" : "not_applicable",
+    reason: packageName2 ? "package_surface_pending_index" : null,
+    recordCap: 256,
+    total: 0,
+    shown: 0,
+    omitted: 0,
+    packageName: packageName2 ?? null,
+    exportsPresent: false,
+    exportsAuthoritative: false,
+    main: null,
+    module: null,
+    entries: [],
+    scopes: []
+  });
+}
+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,
+      package_public_surface_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 ?? {}),
+    initialPackagePublicSurface(r.packageName),
+    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, rows) {
+  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 rows)
+    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, rows) {
+  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 rows) {
+    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, rows) {
+  assertUniquePreparedBindingSites(rows);
+  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,binding_site_start_offset,binding_site_end_offset,owner_resolution,helper_chain_json) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      bindingOwnerId(db, repoId, r),
+      r.variableName,
+      r.alias,
+      r.aliasExpr,
+      r.destinationExpr,
+      r.servicePathExpr,
+      r.isDynamic ? 1 : 0,
+      JSON.stringify(r.placeholders),
+      r.sourceFile,
+      r.sourceLine,
+      r.bindingSiteStartOffset,
+      r.bindingSiteEndOffset,
+      r.ownerResolution,
+      r.helperChain ? JSON.stringify(r.helperChain) : null
+    );
+}
+function persistedOwnerCandidates(db, repoId, fact) {
+  const rows = db.prepare(`SELECT id,kind,qualified_name qualifiedName,
+    start_offset startOffset,end_offset endOffset FROM symbols
+    WHERE repo_id=? AND source_file=? AND start_offset<=? AND end_offset>=?`).all(
+    repoId,
+    fact.sourceFile,
+    fact.bindingSiteStartOffset,
+    fact.bindingSiteEndOffset
+  );
+  return rows.flatMap((row) => typeof row.id === "number" && typeof row.kind === "string" && typeof row.qualifiedName === "string" && typeof row.startOffset === "number" && typeof row.endOffset === "number" ? [{
+    id: row.id,
+    kind: row.kind,
+    qualifiedName: row.qualifiedName,
+    startOffset: row.startOffset,
+    endOffset: row.endOffset
+  }] : []);
+}
+function bindingOwnerId(db, repoId, fact) {
+  const candidates = persistedOwnerCandidates(db, repoId, fact);
+  const selected = selectCallOwner(
+    candidates,
+    fact.bindingSiteStartOffset ?? -1,
+    fact.bindingSiteEndOffset ?? -1
+  );
+  if (fact.ownerResolution === "ownerless_file_scope") {
+    if (selected.status !== "none")
+      throw new Error("invalid_prepared_repository_snapshot:binding_owner_mismatch");
+    return null;
+  }
+  if (fact.ownerResolution !== "owned_exact" || selected.status !== "resolved" || selected.owner?.qualifiedName !== fact.sourceSymbolQualifiedName)
+    throw new Error("invalid_prepared_repository_snapshot:binding_owner_mismatch");
+  const owner = selected.owner;
+  if (!owner)
+    throw new Error("invalid_prepared_repository_snapshot:binding_owner_mismatch");
+  return owner.id;
+}
+function assertUniquePreparedBindingSites(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.bindingSiteStartOffset === void 0 || row.bindingSiteEndOffset === void 0)
+      throw new Error("invalid_prepared_repository_snapshot:binding_site_missing");
+    const key = [
+      row.sourceFile,
+      row.variableName,
+      row.bindingSiteStartOffset,
+      row.bindingSiteEndOffset
+    ].join("\0");
+    if (seen.has(key))
+      throw new Error("invalid_prepared_repository_snapshot:duplicate_service_binding_site");
+    seen.add(key);
+  }
+}
+function insertExecutableSymbols(db, repoId, rows) {
+  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 rows) 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);
+}
+
 // src/discovery/classify-repository.ts
 import fs3 from "fs/promises";
 import path3 from "path";
@@ -258,91 +599,1039 @@ import path5 from "path";
 // src/parsers/symbol-parser.ts
 import fs4 from "fs/promises";
 import path4 from "path";
+import ts8 from "typescript";
+
+// src/parsers/005-event-subscription-facts.ts
+import ts2 from "typescript";
+
+// src/parsers/016-local-symbol-reference.ts
 import ts from "typescript";
-function lineOf(source, pos) {
-  return source.getLineAndCharacterOfPosition(pos).line + 1;
+function functionTargetNode(declaration) {
+  const parent = declaration.parent;
+  if (ts.isFunctionDeclaration(parent)) return parent;
+  if (!ts.isVariableDeclaration(parent)) return void 0;
+  const initializer = parent.initializer;
+  return initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) ? initializer : void 0;
+}
+function declarationKey(identifier) {
+  return `${identifier.getStart(identifier.getSourceFile())}:${identifier.getEnd()}`;
+}
+function unwrapAssignmentTarget(expression) {
+  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression))
+    return unwrapAssignmentTarget(expression.expression);
+  return expression;
+}
+function objectAssignmentTargets(expression) {
+  return expression.properties.flatMap((property) => {
+    if (ts.isShorthandPropertyAssignment(property)) return [property.name];
+    if (ts.isPropertyAssignment(property))
+      return assignmentTargets(property.initializer);
+    return ts.isSpreadAssignment(property) ? assignmentTargets(property.expression) : [];
+  });
 }
-function nameOf(node) {
-  if (!node) return void 0;
-  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return node.text;
-  return void 0;
+function assignmentTargets(expression) {
+  const target = unwrapAssignmentTarget(expression);
+  if (ts.isIdentifier(target)) return [target];
+  if (ts.isSpreadElement(target))
+    return assignmentTargets(target.expression);
+  if (ts.isBinaryExpression(target) && target.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+    return assignmentTargets(target.left);
+  if (ts.isArrayLiteralExpression(target))
+    return target.elements.flatMap((item) => ts.isExpression(item) ? assignmentTargets(item) : []);
+  return ts.isObjectLiteralExpression(target) ? objectAssignmentTargets(target) : [];
+}
+function assignmentOperator(kind) {
+  return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+function mutationUnary(node) {
+  return node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken;
+}
+function binaryWritesDeclaration(node, matches) {
+  if (!ts.isBinaryExpression(node) || !assignmentOperator(node.operatorToken.kind)) return false;
+  return assignmentTargets(node.left).some(matches);
+}
+function unaryWritesDeclaration(node, matches) {
+  if (!ts.isPrefixUnaryExpression(node) && !ts.isPostfixUnaryExpression(node)) return false;
+  return mutationUnary(node) && ts.isIdentifier(node.operand) && matches(node.operand);
+}
+function loopWritesDeclaration(node, matches) {
+  if (!ts.isForInStatement(node) && !ts.isForOfStatement(node)) return false;
+  return !ts.isVariableDeclarationList(node.initializer) && assignmentTargets(node.initializer).some(matches);
+}
+function declarationWritten(source, declarations) {
+  const keys = new Set(declarations.map(declarationKey));
+  let written = false;
+  const matches = (identifier) => lexicalIdentifierDeclarations(identifier).some((item) => keys.has(declarationKey(item)));
+  const visit = (node) => {
+    if (written) return;
+    written = binaryWritesDeclaration(node, matches) || unaryWritesDeclaration(node, matches) || loopWritesDeclaration(node, matches);
+    if (!written) ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return written;
 }
-function isFunctionLike(node) {
-  return ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node);
+function singleImmutableDeclaration(declaration) {
+  const parent = declaration?.parent;
+  if (parent && ts.isClassDeclaration(parent)) return true;
+  return Boolean(parent && ts.isVariableDeclaration(parent) && ts.isVariableDeclarationList(parent.parent) && (parent.parent.flags & ts.NodeFlags.Const) !== 0);
 }
-function exported(node) {
-  return Boolean(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
+function immutableDeclarationSet(declarations, source) {
+  if (declarations.length === 0 || declarationWritten(source, declarations)) return false;
+  if (declarations.every((item) => ts.isFunctionDeclaration(item.parent)))
+    return true;
+  if (declarations.length !== 1) return false;
+  return singleImmutableDeclaration(declarations[0]);
 }
-function isPublicClassMethod(node) {
-  const flags = ts.getCombinedModifierFlags(node);
-  return (flags & ts.ModifierFlags.Private) === 0 && (flags & ts.ModifierFlags.Protected) === 0;
+function propertyContainer(declaration) {
+  const parent = declaration.parent;
+  if (ts.isClassDeclaration(parent)) return parent;
+  if (!ts.isVariableDeclaration(parent)) return void 0;
+  const initializer = parent.initializer;
+  return initializer && (ts.isObjectLiteralExpression(initializer) || ts.isClassExpression(initializer)) ? initializer : void 0;
 }
-function exportDeclarations(source) {
-  const exports = /* @__PURE__ */ new Map();
-  const visit = (node) => {
-    if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
-      for (const el of node.exportClause.elements) exports.set((el.propertyName ?? el.name).text, el.name.text);
-    }
-    ts.forEachChild(node, visit);
+function identity(symbol) {
+  return {
+    sourceFile: symbol.sourceFile,
+    qualifiedName: symbol.qualifiedName,
+    startOffset: symbol.startOffset,
+    endOffset: symbol.endOffset
   };
-  visit(source);
-  return exports;
 }
-function isRelativeImport(value) {
-  return Boolean(value?.startsWith("."));
+function executableBody(symbol) {
+  const value = symbol.importExportEvidence?.executableBodyEligibility;
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && "eligible" in value && value.eligible === true);
+}
+function exactFunctionTarget(declarations, symbols, source) {
+  if (!immutableDeclarationSet(declarations, source)) return void 0;
+  const spans = declarations.flatMap((declaration) => {
+    const target = functionTargetNode(declaration);
+    return target ? [{ start: target.getStart(source), end: target.getEnd() }] : [];
+  });
+  const matches = symbols.filter((symbol) => localFunctionMatches(symbol, spans, source.fileName));
+  return matches.length === 1 && matches[0] ? identity(matches[0]) : void 0;
 }
-function directHandlerReferenceTarget(expression, source, imports, namespaceImports) {
+function localFunctionMatches(symbol, spans, sourceFile2) {
+  if (symbol.sourceFile !== sourceFile2 || !executableBody(symbol))
+    return false;
+  return spans.some((span) => symbol.startOffset === span.start && symbol.endOffset === span.end);
+}
+function exactPropertyTarget(expression, declaration, symbols, source) {
+  if (!immutableDeclarationSet([declaration], source) || !stableLocalValueReference(source, declaration))
+    return void 0;
+  const container = propertyContainer(declaration);
+  if (!container) return void 0;
+  const qualifiedName = `${declaration.text}.${expression.name.text}`;
+  const start = container.getStart(source);
+  const end = container.getEnd();
+  const matches = symbols.filter((symbol) => symbol.sourceFile === source.fileName && symbol.qualifiedName === qualifiedName && symbol.startOffset >= start && symbol.endOffset <= end && executableBody(symbol));
+  return matches.length === 1 && matches[0] ? identity(matches[0]) : void 0;
+}
+function localSymbolTarget(expression, source, symbols) {
   if (ts.isIdentifier(expression)) {
-    const importSource2 = imports.get(expression.text);
+    return exactFunctionTarget(
+      lexicalIdentifierDeclarations(expression),
+      symbols,
+      source
+    );
+  }
+  if (!ts.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts.isIdentifier(expression.expression)) return void 0;
+  const declaration = lexicalIdentifierDeclaration(expression.expression);
+  return declaration ? exactPropertyTarget(expression, declaration, symbols, source) : void 0;
+}
+
+// src/parsers/005-event-subscription-facts.ts
+function lineOf(source, node) {
+  return source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
+}
+function lineAt(source, position) {
+  return source.getLineAndCharacterOfPosition(position).line + 1;
+}
+function importRelation(binding) {
+  if (binding.moduleKind === "package") return "package_import";
+  return binding.referenceShape === "namespace_member" ? "relative_import_namespace_member" : "relative_import";
+}
+function directTarget(expression, source, imports, symbols) {
+  const imported = symbolImportReference(expression, imports);
+  if (imported) return importedTarget(expression, source, imported);
+  if (ts2.isIdentifier(expression)) {
+    const exact = localSymbolTarget(expression, source, symbols);
     return {
       calleeExpression: expression.text,
       calleeLocalName: expression.text,
-      importSource: importSource2,
-      relation: importSource2 ? isRelativeImport(importSource2) ? "relative_import" : "package_import" : "indexed_local_symbol"
+      relation: exact ? "indexed_local_symbol" : "indexed_local_symbol_unproven",
+      referenceShape: "identifier",
+      localTargetIdentity: exact
     };
   }
-  if (!ts.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts.isIdentifier(expression.expression) || !ts.isIdentifier(expression.name))
-    return void 0;
-  const objectName = expression.expression.text;
-  const memberName = expression.name.text;
-  const importSource = imports.get(objectName);
-  if (namespaceImports.has(objectName)) return {
+  return propertyTarget(expression, source, symbols);
+}
+function importedTarget(expression, source, binding) {
+  return {
     calleeExpression: expression.getText(source),
-    calleeLocalName: memberName,
-    importSource,
-    relation: "relative_import_namespace_member"
+    calleeLocalName: binding.requestedPublicName,
+    importSource: binding.rawModuleSpecifier,
+    relation: importRelation(binding),
+    referenceShape: binding.referenceShape,
+    importBinding: binding
   };
-  const qualifiedName = `${objectName}.${memberName}`;
+}
+function propertyTarget(expression, source, symbols) {
+  if (!ts2.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts2.isIdentifier(expression.expression)) return void 0;
+  const exact = localSymbolTarget(expression, source, symbols);
   return {
-    calleeExpression: qualifiedName,
-    calleeLocalName: qualifiedName,
-    importSource,
-    relation: importSource ? isRelativeImport(importSource) ? "relative_import" : "package_import" : "indexed_local_symbol"
+    calleeExpression: expression.getText(source),
+    calleeLocalName: `${expression.expression.text}.${expression.name.text}`,
+    relation: exact ? "indexed_local_symbol" : "indexed_local_symbol_unproven",
+    referenceShape: "static_member",
+    localTargetIdentity: exact
   };
 }
-function handlerReferenceTarget(expression, source, imports, namespaceImports) {
-  const direct = directHandlerReferenceTarget(
-    expression,
+function unsupportedClassification(status, reason, referenceShape) {
+  return { status, reason, referenceShape };
+}
+function classifyHandlerReference(expression, source, imports = collectSymbolImportBindings(source), symbols = []) {
+  if (!expression)
+    return unsupportedClassification(
+      "missing_argument",
+      "handler_argument_missing",
+      "missing"
+    );
+  if (ts2.isArrowFunction(expression) || ts2.isFunctionExpression(expression))
+    return unsupportedClassification(
+      "unsupported_inline",
+      "inline_handler_body_not_indexed",
+      "inline_callback"
+    );
+  const direct = directTarget(expression, source, imports, symbols);
+  if (direct)
+    return { status: "role_required", referenceShape: direct.referenceShape, target: direct };
+  if (!ts2.isCallExpression(expression))
+    return unsupportedClassification(
+      "unsupported_reference_shape",
+      "handler_reference_shape_unsupported",
+      "unsupported_expression"
+    );
+  return classifyWrapperReference(expression, source, imports, symbols);
+}
+function classifyWrapperReference(expression, source, imports, symbols) {
+  if (expression.questionDotToken || expression.arguments.length !== 1)
+    return unsupportedClassification(
+      "unsupported_wrapper",
+      "wrapper_requires_one_reference",
+      "wrapper_call"
+    );
+  const inner = expression.arguments[0];
+  const target = inner ? directTarget(inner, source, imports, symbols) : void 0;
+  if (!target)
+    return unsupportedClassification(
+      "unsupported_wrapper",
+      "wrapper_reference_shape_unsupported",
+      "wrapper_call"
+    );
+  return {
+    status: "role_required",
+    referenceShape: `wrapped_${target.referenceShape}`,
+    target: { ...target, wrapperFunction: expression.expression.getText(source) }
+  };
+}
+function eventSymbol(source, classified) {
+  const node = classified.node;
+  const eventName = classified.fact.eventNameExpr ?? "";
+  const line = lineOf(source, node);
+  const safeName = eventName.replace(/[^A-Za-z0-9_$-]/g, "_");
+  const name = `event:${safeName}:${line}`;
+  const receiver = classified.fact.evidence?.receiver;
+  return {
+    kind: "event_registration",
+    localName: name,
+    qualifiedName: `module:${classified.fact.sourceFile}#${name}`,
+    sourceFile: classified.fact.sourceFile,
+    startLine: line,
+    endLine: lineAt(source, node.getEnd() - 1),
+    startOffset: node.getStart(source),
+    endOffset: node.getEnd(),
+    exported: false,
+    importExportEvidence: {
+      source: "synthetic_event_registration",
+      eventName,
+      registrationLine: line,
+      receiver: typeof receiver === "string" ? receiver : void 0
+    }
+  };
+}
+function eventCall(classified, owner, classification) {
+  const target = classification.target;
+  if (!target) return void 0;
+  return {
+    callerQualifiedName: owner.qualifiedName,
+    calleeExpression: target.calleeExpression,
+    calleeLocalName: target.calleeLocalName,
+    importSource: target.importSource,
+    sourceFile: classified.fact.sourceFile,
+    sourceLine: classified.fact.sourceLine,
+    callSiteStartOffset: classified.fact.callSiteStartOffset,
+    callSiteEndOffset: classified.fact.callSiteEndOffset,
+    callRole: "event_subscribe_handler",
+    evidence: {
+      relation: target.relation,
+      caller: owner.qualifiedName,
+      targetName: target.calleeLocalName,
+      referenceShape: classification.referenceShape,
+      ...target.importBinding ? { importBinding: target.importBinding } : {},
+      ...target.localTargetIdentity ? { localTargetIdentity: target.localTargetIdentity } : {},
+      ...target.wrapperFunction ? { wrapperFunction: target.wrapperFunction } : {},
+      factOrigin: "event_subscribe_handler_reference"
+    }
+  };
+}
+function enrichSubscription(source, classified, symbols) {
+  const classification = classifyHandlerReference(
+    classified.node.arguments[1],
     source,
-    imports,
-    namespaceImports
+    void 0,
+    symbols
   );
-  if (direct) return direct;
-  if (!ts.isCallExpression(expression) || expression.questionDotToken || expression.arguments.length !== 1) return void 0;
-  const inner = directHandlerReferenceTarget(
-    expression.arguments[0],
+  const evidence = {
+    ...classified.fact.evidence ?? {},
+    handlerReferenceStatus: classification.status,
+    ...classification.reason ? { handlerReferenceReason: classification.reason } : {},
+    handlerReferenceShape: classification.referenceShape
+  };
+  return {
+    classified: { ...classified, fact: { ...classified.fact, evidence } },
+    classification
+  };
+}
+function reconcileEventSubscriptions(source, classifications, symbols, calls) {
+  const subscriptions = classifications.filter(
+    (item) => item.fact.callType === "async_subscribe"
+  ).map((item) => enrichSubscription(source, item, symbols));
+  const eventSymbols = subscriptions.map((item) => eventSymbol(source, item.classified));
+  const eventCalls = subscriptions.flatMap((item, index) => {
+    const owner = eventSymbols[index];
+    const call = owner ? eventCall(item.classified, owner, item.classification) : void 0;
+    return call ? [call] : [];
+  });
+  return {
+    classifications: classifications.map((item) => subscriptions.find((candidate) => candidate.classified.node === item.node)?.classified ?? item),
+    symbols: [...symbols.filter((item) => item.kind !== "event_registration"), ...eventSymbols],
+    calls: [
+      ...calls.filter((item) => item.callRole !== "event_subscribe_handler"),
+      ...eventCalls
+    ]
+  };
+}
+
+// src/parsers/007-source-fact-reconciliation.ts
+import "typescript";
+
+// src/parsers/006-binding-identity.ts
+import ts3 from "typescript";
+var scopeChainCap = 16;
+function matchFactsToSites(index, facts) {
+  return facts.map((fact) => {
+    if (fact.bindingSiteStartOffset === void 0 || fact.bindingSiteEndOffset === void 0)
+      throw new Error("invalid_prepared_repository_snapshot:binding_site_missing");
+    const site = bindingSite(
+      index,
+      fact.variableName,
+      fact.bindingSiteStartOffset,
+      fact.bindingSiteEndOffset
+    );
+    if (!site)
+      throw new Error("invalid_prepared_repository_snapshot:binding_site_invalid");
+    return { fact, site };
+  });
+}
+function exactOwner(fact, site, symbols) {
+  const candidates = executableSymbolCandidates(symbols, fact.sourceFile);
+  const owner = selectCallOwner(
+    candidates,
+    site.startOffset,
+    site.endOffset
+  );
+  if (owner.status === "ambiguous")
+    throw new Error("invalid_prepared_repository_snapshot:binding_owner_ambiguous");
+  return {
+    ...fact,
+    bindingSiteStartOffset: site.startOffset,
+    bindingSiteEndOffset: site.endOffset,
+    sourceSymbolQualifiedName: owner.owner?.qualifiedName,
+    ownerResolution: owner.status === "resolved" ? "owned_exact" : "ownerless_file_scope"
+  };
+}
+function prepareBindings(index, facts, symbols) {
+  return matchFactsToSites(index, facts).map(({ fact, site }) => ({
+    fact: exactOwner(fact, site, symbols),
+    site,
+    aliasProven: site.aliasSource === void 0
+  }));
+}
+function aliasStep(binding, source) {
+  const aliasKind = binding.site.aliasKind ?? (binding.site.flow === "assignment" ? "identity-assignment" : "identity");
+  return {
+    callerVariable: binding.fact.variableName,
+    aliasOf: source.fact.variableName,
+    aliasKind,
+    scopeRule: "exact_lexical_scope",
+    ...aliasKind === "transaction" ? { transactionAliasSource: source.fact.variableName } : {},
+    ...binding.site.aliasArrayIndex === void 0 ? {} : {
+      sourceVariable: source.fact.variableName,
+      arrayIndex: binding.site.aliasArrayIndex,
+      promiseAll: binding.site.aliasPromiseAll ?? false,
+      arrayContainer: binding.site.aliasPromiseAll ? "Promise.all" : "array_literal"
+    }
+  };
+}
+function copyAliasProvenance(binding, source) {
+  binding.fact = {
+    ...binding.fact,
+    alias: source.fact.alias,
+    aliasExpr: source.fact.aliasExpr,
+    destinationExpr: source.fact.destinationExpr,
+    servicePathExpr: source.fact.servicePathExpr,
+    isDynamic: source.fact.isDynamic,
+    placeholders: source.fact.placeholders,
+    helperChain: [
+      ...source.fact.helperChain ?? [],
+      aliasStep(binding, source)
+    ]
+  };
+  binding.aliasProven = true;
+}
+function bindingCandidates(bindings) {
+  return bindings.map((binding) => ({
+    variableName: binding.fact.variableName,
+    bindingSiteStartOffset: binding.site.startOffset,
+    bindingSiteEndOffset: binding.site.endOffset,
+    value: binding
+  }));
+}
+function resolvedAliasSource(selected) {
+  if (selected.status !== "resolved") return void 0;
+  if (!selected.site?.deterministic) return void 0;
+  if (selected.declarationSite?.declarationKind === "var") return void 0;
+  const source = selected.candidate?.value;
+  return source?.aliasProven ? source : void 0;
+}
+function reconcileAliases(index, bindings) {
+  const candidates = bindingCandidates(bindings);
+  for (const binding of bindings) {
+    const sourceName = binding.site.aliasSource;
+    if (!sourceName) continue;
+    const selected = selectVisibleBinding(
+      index,
+      candidates,
+      sourceName,
+      binding.site.node
+    );
+    const source = resolvedAliasSource(selected);
+    if (source) copyAliasProvenance(binding, source);
+  }
+}
+function assertUniqueSites(bindings) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    const key = [
+      binding.fact.sourceFile,
+      binding.fact.variableName,
+      binding.site.startOffset,
+      binding.site.endOffset
+    ].join("\0");
+    if (seen.has(key))
+      throw new Error("invalid_prepared_repository_snapshot:duplicate_service_binding_site");
+    seen.add(key);
+  }
+}
+function callNodeMap(source) {
+  const calls = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts3.isCallExpression(node))
+      calls.set(`${node.getStart(source)}:${node.getEnd()}`, node);
+    ts3.forEachChild(node, visit);
+  };
+  visit(source);
+  return calls;
+}
+function emptyReference(call, reason) {
+  return {
+    status: call.serviceVariableName ? "unresolved" : "not_applicable",
+    variableName: call.serviceVariableName,
+    scopeChainTotal: 0,
+    scopeChainShown: 0,
+    scopeChainOmitted: 0,
+    reason
+  };
+}
+function rejectedReference(call, chain, reason, status = "unresolved") {
+  return {
+    status,
+    variableName: call.serviceVariableName,
+    scopeChainTotal: chain.length,
+    scopeChainShown: Math.min(chain.length, scopeChainCap),
+    scopeChainOmitted: Math.max(0, chain.length - scopeChainCap),
+    reason
+  };
+}
+function resolvedReference(call, selected, chain, scopeIndex) {
+  return {
+    status: "resolved_exact",
+    variableName: call.serviceVariableName,
+    bindingSourceFile: selected.fact.sourceFile,
+    bindingSiteStartOffset: selected.site.startOffset,
+    bindingSiteEndOffset: selected.site.endOffset,
+    resolutionStrategy: selected.site.flow === "assignment" ? "deterministic_reaching_assignment" : selected.site.aliasSource ? "lexical_alias_declaration" : "lexical_declaration",
+    lexicalScopeChain: chain,
+    bindingScopeIndex: scopeIndex,
+    scopeChainTotal: chain.length,
+    scopeChainShown: chain.length,
+    scopeChainOmitted: 0
+  };
+}
+function selectedBindingReference(call, chain, chosen) {
+  const selected = chosen.candidate?.value;
+  if (!selected) {
+    return rejectedReference(
+      call,
+      chain,
+      chosen.reason ?? "binding_not_found"
+    );
+  }
+  if (chosen.declarationSite?.declarationKind === "var")
+    return rejectedReference(call, chain, "unsupported_var_binding");
+  if (!selected.site.deterministic || !selected.aliasProven)
+    return rejectedReference(call, chain, "unsupported_reaching_assignment");
+  return resolvedReference(call, selected, chain, chosen.scopeIndex ?? 0);
+}
+function bindingReference(call, node, index, bindings) {
+  if (!call.serviceVariableName) return emptyReference(call);
+  if (!node) return emptyReference(call, "binding_flow_unsupported");
+  const chain = lexicalScopeChain(node, index.source);
+  if (chain.length > scopeChainCap)
+    return rejectedReference(call, chain, "scope_chain_limit_exceeded");
+  const chosen = selectVisibleBinding(
+    index,
+    bindingCandidates(bindings),
+    call.serviceVariableName,
+    node
+  );
+  if (chosen.status === "ambiguous")
+    return rejectedReference(
+      call,
+      chain,
+      "binding_scope_ambiguous",
+      "ambiguous"
+    );
+  return selectedBindingReference(call, chain, chosen);
+}
+function exactCallOwner(call, symbols) {
+  const start = call.callSiteStartOffset;
+  const end = call.callSiteEndOffset;
+  if (start === void 0 || end === void 0)
+    return { resolution: "ownerless_file_scope" };
+  const selected = selectCallOwner(
+    executableSymbolCandidates(symbols, call.sourceFile),
+    start,
+    end,
+    call.callType === "async_subscribe"
+  );
+  if (selected.status === "ambiguous")
+    throw new Error("invalid_prepared_repository_snapshot:outbound_owner_ambiguous");
+  if (call.callType === "async_subscribe" && selected.status !== "resolved")
+    throw new Error("invalid_prepared_repository_snapshot:subscription_owner_missing");
+  return selected.owner ? { qualifiedName: selected.owner.qualifiedName, resolution: "owned_exact" } : { resolution: "ownerless_file_scope" };
+}
+function reconcileBindingAndCallIdentity(source, bindingFacts, callFacts, symbols) {
+  const lexicalIndex = createBindingLexicalIndex(source);
+  const bindings = prepareBindings(lexicalIndex, bindingFacts, symbols);
+  reconcileAliases(lexicalIndex, bindings);
+  assertUniqueSites(bindings);
+  const nodes = callNodeMap(source);
+  const calls = callFacts.map((call) => {
+    const key = `${call.callSiteStartOffset}:${call.callSiteEndOffset}`;
+    const reference = bindingReference(
+      call,
+      nodes.get(key),
+      lexicalIndex,
+      bindings
+    );
+    const owner = exactCallOwner(call, symbols);
+    return {
+      ...call,
+      sourceSymbolQualifiedName: owner.qualifiedName,
+      serviceBindingReference: reference,
+      evidence: {
+        ...call.evidence ?? {},
+        sourceOwnerResolution: owner.resolution,
+        serviceBindingReference: reference
+      }
+    };
+  });
+  return { bindings: bindings.map((binding) => binding.fact), calls };
+}
+
+// src/parsers/007-source-fact-reconciliation.ts
+function callKey(call) {
+  return `${call.callType}:${call.callSiteStartOffset}:${call.callSiteEndOffset}`;
+}
+function mergedOutboundCalls(existing, classifications) {
+  const classifiedKeys = new Set(
+    classifications.map((item) => callKey(item.fact))
+  );
+  return [
+    ...classifications.map((item) => item.fact),
+    ...existing.filter((call) => !classifiedKeys.has(callKey(call)))
+  ];
+}
+function exactSymbolCallOwner(call, symbols) {
+  const start = call.callSiteStartOffset;
+  const end = call.callSiteEndOffset;
+  if (start === void 0 || end === void 0) return void 0;
+  const selected = selectCallOwner(
+    executableSymbolCandidates(symbols, call.sourceFile),
+    start,
+    end,
+    call.callRole === "event_subscribe_handler"
+  );
+  if (selected.status === "ambiguous")
+    throw new Error("invalid_prepared_repository_snapshot:symbol_call_owner_ambiguous");
+  if (call.callRole === "event_subscribe_handler" && !selected.owner)
+    throw new Error("invalid_prepared_repository_snapshot:handler_owner_missing");
+  return selected.owner;
+}
+function reconcileSymbolCallOwners(calls, symbols) {
+  return calls.flatMap((call) => {
+    const owner = exactSymbolCallOwner(call, symbols);
+    if (!owner) return [];
+    return [{
+      ...call,
+      callerQualifiedName: owner.qualifiedName,
+      evidence: {
+        ...call.evidence,
+        caller: owner.qualifiedName,
+        callerResolution: "full_span_containment"
+      }
+    }];
+  });
+}
+function reconcileSourceFacts(source, classifications, bindings, outboundCalls, symbols, symbolCalls) {
+  const events = reconcileEventSubscriptions(
+    source,
+    classifications,
+    symbols,
+    symbolCalls
+  );
+  const allCalls = mergedOutboundCalls(outboundCalls, events.classifications);
+  const identities = reconcileBindingAndCallIdentity(
     source,
-    imports,
-    namespaceImports
+    bindings,
+    allCalls,
+    events.symbols
   );
-  return inner ? { ...inner, wrapperFunction: expression.expression.getText(source) } : void 0;
+  return {
+    bindings: identities.bindings,
+    outboundCalls: identities.calls,
+    symbols: events.symbols,
+    symbolCalls: reconcileSymbolCallOwners(events.calls, events.symbols),
+    classifications: events.classifications
+  };
 }
-function isObjectFunction(node) {
-  return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
+
+// src/parsers/009-symbol-call-facts.ts
+import ts5 from "typescript";
+var commonTerminalMembers = /* @__PURE__ */ new Set([
+  "push",
+  "includes",
+  "find",
+  "findIndex",
+  "map",
+  "filter",
+  "reduce",
+  "forEach",
+  "some",
+  "every",
+  "toUpperCase",
+  "toLowerCase",
+  "trim",
+  "split",
+  "join",
+  "get",
+  "set",
+  "has"
+]);
+var loggerMembers = /* @__PURE__ */ new Set([
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+  "log"
+]);
+var globalObjects = /* @__PURE__ */ new Set([
+  "JSON",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Math",
+  "Date",
+  "Promise",
+  "Reflect"
+]);
+var capDslRoots = /* @__PURE__ */ new Set([
+  "SELECT",
+  "INSERT",
+  "UPSERT",
+  "UPDATE",
+  "DELETE"
+]);
+var requestHelpers = /* @__PURE__ */ new Set([
+  "reject",
+  "error",
+  "info",
+  "warn",
+  "notify"
+]);
+var transportMembers = /* @__PURE__ */ new Set([
+  "emit",
+  "publish",
+  "send",
+  "on"
+]);
+var cdsFrameworkPrefixes = [
+  "cds.connect.",
+  "cds.services.",
+  "cds.parse."
+];
+function symbolCallName(expr) {
+  if (ts5.isIdentifier(expr)) return { expression: expr.text, local: expr.text };
+  if (!ts5.isPropertyAccessExpression(expr))
+    return { expression: expr.getText() };
+  const left = expr.expression.getText();
+  return {
+    expression: expr.getText(),
+    local: left === "this" ? void 0 : left.split(".")[0],
+    member: expr.name.text,
+    receiver: left
+  };
+}
+function hasSetMember(value, values) {
+  return value ? values.has(value) : false;
+}
+function cdsFrameworkCall(callee) {
+  return callee.expression === "cds.run" || cdsFrameworkPrefixes.some((prefix) => callee.expression.startsWith(prefix));
+}
+function requestHelperCall(callee) {
+  return callee.local === "req" && hasSetMember(callee.member, requestHelpers);
+}
+function ignoredFrameworkCall(callee) {
+  const checks = [
+    hasSetMember(callee.local, capDslRoots),
+    cdsFrameworkCall(callee),
+    requestHelperCall(callee),
+    hasSetMember(callee.member, transportMembers),
+    hasSetMember(callee.local, globalObjects),
+    callee.expression.startsWith("new Date().")
+  ];
+  return checks.some(Boolean);
+}
+function argumentEvidence(args) {
+  return args.map((arg) => {
+    if (ts5.isIdentifier(arg)) return { kind: "identifier", name: arg.text };
+    if (ts5.isArrayLiteralExpression(arg)) return {
+      kind: "array_literal",
+      elements: arg.elements.flatMap((item, index) => ts5.isIdentifier(item) ? [{ index, kind: "identifier", name: item.text }] : [])
+    };
+    if (ts5.isObjectLiteralExpression(arg))
+      return objectArgumentEvidence(arg);
+    return { kind: "unsupported", expression: arg.getText() };
+  });
+}
+function objectArgumentEvidence(argument) {
+  const properties = argument.properties.flatMap((property) => {
+    if (ts5.isShorthandPropertyAssignment(property))
+      return [{
+        kind: "shorthand",
+        property: property.name.text,
+        argument: property.name.text
+      }];
+    if (!ts5.isPropertyAssignment(property) || !ts5.isIdentifier(property.initializer)) return [];
+    const name = propertyName(property.name);
+    return name ? [{
+      kind: "property_assignment",
+      property: name,
+      argument: property.initializer.text
+    }] : [];
+  });
+  return { kind: "object_literal", properties };
+}
+function propertyName(name) {
+  return ts5.isIdentifier(name) || ts5.isStringLiteralLike(name) || ts5.isNumericLiteral(name) ? name.text : void 0;
+}
+function exactCaller(collection, node) {
+  const selected = selectCallOwner(
+    executableSymbolCandidates(collection.symbols, collection.sourceFile),
+    node.getStart(collection.source),
+    node.getEnd()
+  );
+  if (selected.status === "ambiguous")
+    throw new Error("invalid_prepared_repository_snapshot:symbol_call_owner_ambiguous");
+  return selected.owner;
+}
+function relation(reference, instance, proxy, localTarget, provenThisMethod) {
+  const derived = derivedRelation(instance, proxy);
+  if (derived) return derived;
+  if (reference?.moduleKind === "package") return "package_import";
+  if (reference?.referenceShape === "namespace_member")
+    return "relative_import_namespace_member";
+  if (reference) return "relative_import";
+  if (localTarget) return "indexed_local_symbol";
+  return provenThisMethod ? "indexed_this_method" : "indexed_local_symbol";
+}
+function derivedRelation(instance, proxy) {
+  if (instance?.importBinding?.moduleKind === "package")
+    return "package_import_derived_member";
+  if (instance) return "class_instance_method";
+  if (proxy?.importBinding.moduleKind === "package")
+    return "package_import_derived_member";
+  return proxy ? "relative_import_proxy_member" : void 0;
+}
+function targetName(callee, reference, instance, proxy) {
+  if (instance && callee.member)
+    return `${instance.className}.${callee.member}`;
+  if (proxy && callee.member) return callee.member;
+  if (callee.receiver === "this") return callee.member;
+  if (reference) return reference.requestedPublicName;
+  return callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
+}
+function callFact(collection, node) {
+  const caller = exactCaller(collection, node);
+  if (!caller) return void 0;
+  const callee = symbolCallName(node.expression);
+  const proxy = callProxy(collection, node);
+  const instance = callInstance(collection, node, callee);
+  const reference = callImportReference(
+    collection,
+    node.expression,
+    callee,
+    instance,
+    proxy
+  );
+  const localTarget = reference || instance || proxy ? void 0 : localSymbolTarget(node.expression, collection.source, collection.symbols);
+  return retainedCallFact(collection, node, caller, callee, {
+    proxy,
+    instance,
+    reference,
+    localTarget
+  });
+}
+function expressionRoot(expression) {
+  let current = expression;
+  while (ts5.isPropertyAccessExpression(current))
+    current = current.expression;
+  return ts5.isIdentifier(current) ? current : void 0;
+}
+function exactDeclaredContext(identifier, candidates) {
+  const matches = candidates.filter((candidate) => identifierMatchesDeclaration(
+    identifier,
+    candidate.declarationStartOffset,
+    candidate.declarationEndOffset
+  ));
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function callProxy(collection, node) {
+  const root = expressionRoot(node.expression);
+  if (!root) return void 0;
+  return exactDeclaredContext(
+    root,
+    collection.proxies.get(root.text) ?? []
+  );
+}
+function callInstance(collection, node, callee) {
+  const root = expressionRoot(node.expression);
+  if (root && root.text !== "this") {
+    const exact = exactDeclaredContext(
+      root,
+      collection.instances.get(root.text) ?? []
+    );
+    if (exact) return exact;
+  }
+  return callee.receiver ? thisPropertyInstance(collection, node, callee.receiver) : void 0;
+}
+function enclosingClass(node) {
+  let current = node.parent;
+  while (current && !ts5.isSourceFile(current)) {
+    if (ts5.isClassLike(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function thisPropertyInstance(collection, node, receiver) {
+  if (!receiver.startsWith("this.")) return void 0;
+  const container = enclosingClass(node);
+  if (!container) return void 0;
+  const start = container.getStart(collection.source);
+  const end = container.getEnd();
+  const matches = (collection.instances.get(receiver) ?? []).filter(
+    (candidate) => candidate.containerStartOffset === start && candidate.containerEndOffset === end
+  );
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function callImportReference(collection, expression, callee, instance, proxy) {
+  const direct = symbolImportReference(expression, collection.importBindings);
+  if (direct || !callee.member) return direct;
+  const inherited = instance?.importBinding ?? proxy?.importBinding;
+  return inherited ? derivedMemberImportReference(inherited, callee.member) : void 0;
+}
+function retainedCallFact(collection, node, caller, callee, context) {
+  const target = targetName(
+    callee,
+    context.reference,
+    context.instance,
+    context.proxy
+  );
+  const className = caller.qualifiedName.includes(".") ? caller.qualifiedName.split(".")[0] : void 0;
+  const thisTarget = callee.receiver === "this" && className && callee.member ? `${className}.${callee.member}` : void 0;
+  const resolvedTarget = thisTarget ?? target;
+  if (!resolvedTarget || !shouldRetainCall(
+    collection,
+    callee,
+    resolvedTarget,
+    context,
+    Boolean(thisTarget)
+  ))
+    return void 0;
+  return createCallFact(
+    collection,
+    node,
+    caller,
+    callee,
+    resolvedTarget,
+    thisTarget,
+    context
+  );
+}
+function shouldRetainCall(collection, callee, target, context, provenThisMethod) {
+  if (!target || ignoredCall(callee)) return false;
+  const callables = new Set(collection.symbols.flatMap((symbol) => [symbol.localName, symbol.qualifiedName]));
+  return provenThisMethod || Boolean(context.localTarget) || callables.has(target) && Boolean(context.instance) || hasImportedContext(context);
+}
+function ignoredCall(callee) {
+  return loggerCall(callee) || terminalCall(callee) || ignoredFrameworkCall(callee);
+}
+function loggerCall(callee) {
+  if (callee.local === "logger") return true;
+  if (callee.receiver?.endsWith(".logger")) return true;
+  return callee.expression.startsWith("this.logger.") && hasSetMember(callee.member, loggerMembers);
+}
+function terminalCall(callee) {
+  return hasSetMember(callee.member, commonTerminalMembers) || hasSetMember(callee.member, loggerMembers);
+}
+function hasImportedContext(context) {
+  return Boolean(context.reference ?? context.proxy ?? context.instance);
+}
+function createCallFact(collection, node, caller, callee, target, thisTarget, context) {
+  const importSource = context.instance?.importSource ?? context.proxy?.importSource ?? context.reference?.rawModuleSpecifier;
+  return {
+    callerQualifiedName: caller.qualifiedName,
+    calleeExpression: callee.expression,
+    calleeLocalName: target,
+    receiverLocalName: callee.member ? callee.local ?? callee.receiver : void 0,
+    importSource,
+    sourceFile: collection.sourceFile,
+    sourceLine: collection.source.getLineAndCharacterOfPosition(
+      node.getStart(collection.source)
+    ).line + 1,
+    callSiteStartOffset: node.getStart(collection.source),
+    callSiteEndOffset: node.getEnd(),
+    callRole: "ordinary_call",
+    evidence: callEvidence(caller, callee, target, thisTarget, context, node)
+  };
+}
+function callEvidence(caller, callee, target, thisTarget, context, node) {
+  return {
+    relation: relation(
+      context.reference,
+      context.instance,
+      context.proxy,
+      context.localTarget,
+      Boolean(thisTarget)
+    ),
+    caller: caller.qualifiedName,
+    targetName: target,
+    ...importReferenceEvidence(context),
+    ...instanceEvidence(context.instance, callee),
+    callArguments: argumentEvidence(node.arguments),
+    ...proxyEvidence(context.proxy),
+    ...context.localTarget ? { localTargetIdentity: context.localTarget } : {},
+    candidateStrategy: parserCandidateStrategy(context)
+  };
+}
+function importReferenceEvidence(context) {
+  if (!context.reference) return {};
+  const derived = context.instance ?? context.proxy;
+  return derived && context.reference.moduleKind === "package" ? { derivedImportBinding: context.reference } : { importBinding: context.reference };
+}
+function instanceEvidence(instance, callee) {
+  if (!instance) return {};
+  return {
+    instanceVariable: instance.propertyName ?? callee.local,
+    className: instance.className,
+    methodName: callee.member,
+    classImportSource: instance.importSource,
+    classImportBinding: instance.importBinding
+  };
+}
+function proxyEvidence(proxy) {
+  if (!proxy) return {};
+  return {
+    proxyVariableName: proxy.variableName,
+    factory: proxy.factory,
+    factoryExpression: proxy.factory,
+    factoryImportSource: proxy.importSource,
+    factoryImportBinding: proxy.importBinding
+  };
 }
-var commonTerminalMembers = /* @__PURE__ */ new Set(["push", "includes", "find", "findIndex", "map", "filter", "reduce", "forEach", "some", "every", "toUpperCase", "toLowerCase", "trim", "split", "join", "get", "set", "has"]);
-var loggerMembers = /* @__PURE__ */ new Set(["trace", "debug", "info", "warn", "error", "fatal", "log"]);
-var globalObjects = /* @__PURE__ */ new Set(["JSON", "Object", "Array", "String", "Number", "Boolean", "Math", "Date", "Promise", "Reflect"]);
+function parserCandidateStrategy(context) {
+  if (context.instance?.importSource)
+    return "relative_import_class_instance_method";
+  if (context.instance) return "same_file_class_instance_method";
+  return context.proxy ? "proxy_member_exact_export_or_unique_member" : void 0;
+}
+function collectSymbolCallFacts(collection) {
+  const calls = [];
+  const visit = (node) => {
+    if (ts5.isCallExpression(node)) {
+      const call = callFact(collection, node);
+      if (call) calls.push(call);
+    }
+    ts5.forEachChild(node, visit);
+  };
+  visit(collection.source);
+  return calls;
+}
+
+// src/parsers/013-executable-body-eligibility.ts
+import ts6 from "typescript";
+function hasModifier(node, kind) {
+  return ts6.canHaveModifiers(node) && Boolean(ts6.getModifiers(node)?.some((item) => item.kind === kind));
+}
+function executableBodyEligibility(node, source) {
+  if (node.body) return { eligible: true, reason: "body_present" };
+  if (hasModifier(node, ts6.SyntaxKind.AbstractKeyword))
+    return { eligible: false, reason: "abstract_bodyless" };
+  if (hasModifier(node, ts6.SyntaxKind.DeclareKeyword))
+    return { eligible: false, reason: "ambient_declaration" };
+  return {
+    eligible: false,
+    reason: source.isDeclarationFile ? "declaration_only" : "overload_signature"
+  };
+}
+
+// src/parsers/017-symbol-derived-contexts.ts
+import ts7 from "typescript";
 var builtInConstructors = /* @__PURE__ */ new Set([
   "Set",
   "Map",
@@ -377,86 +1666,222 @@ var builtInConstructors = /* @__PURE__ */ new Set([
   "Promise",
   "AbortController"
 ]);
-var capDslRoots = /* @__PURE__ */ new Set(["SELECT", "INSERT", "UPSERT", "UPDATE", "DELETE"]);
-var requestHelpers = /* @__PURE__ */ new Set(["reject", "error", "info", "warn", "notify"]);
-var transportMembers = /* @__PURE__ */ new Set(["emit", "publish", "send", "on"]);
-function callName(expr) {
-  if (ts.isIdentifier(expr)) return { expression: expr.text, local: expr.text };
-  if (ts.isPropertyAccessExpression(expr)) {
-    const left = expr.expression.getText();
-    const root = left.split(".")[0];
-    return { expression: expr.getText(), local: left === "this" ? void 0 : root, member: expr.name.text, receiver: left };
-  }
-  return { expression: expr.getText() };
+function appendNamed(values, name, value) {
+  const matches = values.get(name) ?? [];
+  matches.push(value);
+  values.set(name, matches);
+}
+function assignmentOperator2(kind) {
+  return kind >= ts7.SyntaxKind.FirstAssignment && kind <= ts7.SyntaxKind.LastAssignment;
+}
+function mutationUnary2(node) {
+  return node.operator === ts7.SyntaxKind.PlusPlusToken || node.operator === ts7.SyntaxKind.MinusMinusToken;
+}
+function receiverIdentifier(expression) {
+  let current = expression;
+  while (ts7.isPropertyAccessExpression(current) || ts7.isElementAccessExpression(current))
+    current = current.expression;
+  return ts7.isIdentifier(current) ? current : void 0;
+}
+function nodeWritesMember(node, matches) {
+  if (ts7.isBinaryExpression(node))
+    return assignmentOperator2(node.operatorToken.kind) && matches(node.left);
+  if (ts7.isPrefixUnaryExpression(node) || ts7.isPostfixUnaryExpression(node))
+    return mutationUnary2(node) && matches(node.operand);
+  return ts7.isDeleteExpression(node) && matches(node.expression);
+}
+function memberWrite(source, declaration) {
+  const start = declaration.getStart(source);
+  const end = declaration.getEnd();
+  const matches = (expression) => {
+    const receiver = receiverIdentifier(expression);
+    return Boolean(receiver && receiver !== expression && identifierMatchesDeclaration(receiver, start, end));
+  };
+  let written = false;
+  const visit = (node) => {
+    if (written) return;
+    written = nodeWritesMember(node, matches);
+    if (!written) ts7.forEachChild(node, visit);
+  };
+  visit(source);
+  return written;
 }
-function requireSource(expr) {
-  if (!ts.isCallExpression(expr) || !ts.isIdentifier(expr.expression) || expr.expression.text !== "require") return void 0;
-  const first = expr.arguments[0];
-  return first && ts.isStringLiteral(first) ? first.text : void 0;
+function stableVariable(collection, node) {
+  return ts7.isIdentifier(node.name) && ts7.isVariableDeclarationList(node.parent) && (node.parent.flags & ts7.NodeFlags.Const) !== 0 && !memberWrite(collection.source, node.name);
 }
-function ignoredFrameworkCall(callee) {
-  if (callee.local && capDslRoots.has(callee.local)) return true;
-  if (callee.expression === "cds.run" || callee.expression.startsWith("cds.connect.") || callee.expression.startsWith("cds.services.") || callee.expression.startsWith("cds.parse.")) return true;
-  if (callee.local === "req" && callee.member && requestHelpers.has(callee.member)) return true;
-  if (callee.member && transportMembers.has(callee.member)) return true;
-  if (callee.local && globalObjects.has(callee.local)) return true;
-  if (callee.expression.startsWith("new Date().")) return true;
-  return false;
-}
-function nearest(symbols, line) {
-  return symbols.filter((s) => s.startLine <= line && s.endLine >= line).sort((a, b) => a.endLine - a.startLine - (b.endLine - b.startLine))[0];
-}
-function argumentEvidence(args, source) {
-  return args.map((arg) => {
-    if (ts.isIdentifier(arg)) return { kind: "identifier", name: arg.text };
-    if (ts.isObjectLiteralExpression(arg)) {
-      const properties = [];
-      for (const prop of arg.properties) {
-        if (ts.isShorthandPropertyAssignment(prop)) properties.push({ kind: "shorthand", property: prop.name.text, argument: prop.name.text });
-        if (ts.isPropertyAssignment(prop)) {
-          const propName = nameOf(prop.name);
-          if (propName && ts.isIdentifier(prop.initializer)) properties.push({ kind: "property_assignment", property: propName, argument: prop.initializer.text });
-        }
-      }
-      return { kind: "object_literal", properties };
-    }
-    if (ts.isArrayLiteralExpression(arg)) {
-      const elements = arg.elements.flatMap((element, index) => ts.isIdentifier(element) ? [{ index, kind: "identifier", name: element.text }] : []);
-      return { kind: "array_literal", elements };
-    }
-    return { kind: "unsupported", expression: arg.getText(source) };
+function collectProxy(collection, node) {
+  if (!ts7.isVariableDeclaration(node) || !stableVariable(collection, node) || !node.initializer || !ts7.isCallExpression(node.initializer) || !ts7.isPropertyAccessExpression(node.initializer.expression)) return;
+  const callee = symbolCallName(node.initializer.expression);
+  const binding = symbolImportReference(
+    node.initializer.expression,
+    collection.importBindings
+  );
+  if (!callee.member || !binding) return;
+  appendNamed(collection.proxies, node.name.text, {
+    importSource: binding.rawModuleSpecifier,
+    importBinding: binding,
+    factory: callee.expression,
+    variableName: node.name.text,
+    declarationStartOffset: node.name.getStart(collection.source),
+    declarationEndOffset: node.name.getEnd()
   });
 }
+function propertyContainer2(declaration, propertyName3) {
+  const property = propertyName3 && ts7.isPropertyDeclaration(declaration.parent) ? declaration.parent : void 0;
+  return property && ts7.isClassLike(property.parent) ? property.parent : void 0;
+}
+function eligibleClassName(collection, className, imported) {
+  if (builtInConstructors.has(className)) return false;
+  return Boolean(imported || collection.declaredClasses.has(className));
+}
+function resolvedClassName(className, imported) {
+  const importedName = imported?.importedName;
+  return importedName && importedName !== "default" ? importedName : className;
+}
+function rememberInstance(collection, declaration, classExpression, propertyName3) {
+  const className = classExpression.text;
+  const imported = symbolImportReference(
+    classExpression,
+    collection.importBindings
+  );
+  if (!eligibleClassName(collection, className, imported)) return;
+  const container = propertyContainer2(declaration, propertyName3);
+  const variableName = propertyName3 ? `this.${propertyName3}` : declaration.getText();
+  appendNamed(collection.instances, variableName, {
+    className: resolvedClassName(className, imported),
+    importSource: imported?.rawModuleSpecifier,
+    importBinding: imported,
+    propertyName: propertyName3,
+    declarationStartOffset: declaration.getStart(collection.source),
+    declarationEndOffset: declaration.getEnd(),
+    containerStartOffset: container?.getStart(collection.source),
+    containerEndOffset: container?.getEnd()
+  });
+}
+function collectVariableInstance(collection, node) {
+  if (!ts7.isVariableDeclaration(node) || !stableVariable(collection, node))
+    return;
+  const initializer = node.initializer;
+  if (initializer && ts7.isNewExpression(initializer) && ts7.isIdentifier(initializer.expression))
+    rememberInstance(collection, node.name, initializer.expression);
+}
+function propertyName2(name) {
+  return ts7.isIdentifier(name) || ts7.isStringLiteralLike(name) || ts7.isNumericLiteral(name) ? name.text : void 0;
+}
+function thisPropertyWrite(expression, name) {
+  if (ts7.isPropertyAccessExpression(expression))
+    return expression.expression.kind === ts7.SyntaxKind.ThisKeyword && expression.name.text === name;
+  return ts7.isElementAccessExpression(expression) && expression.expression.kind === ts7.SyntaxKind.ThisKeyword && Boolean(expression.argumentExpression && ts7.isStringLiteralLike(expression.argumentExpression) && expression.argumentExpression.text === name);
+}
+function nodeWritesThisProperty(node, name) {
+  if (ts7.isBinaryExpression(node))
+    return assignmentOperator2(node.operatorToken.kind) && thisPropertyWrite(node.left, name);
+  if (ts7.isPrefixUnaryExpression(node) || ts7.isPostfixUnaryExpression(node))
+    return mutationUnary2(node) && thisPropertyWrite(node.operand, name);
+  return ts7.isDeleteExpression(node) && thisPropertyWrite(node.expression, name);
+}
+function stableProperty(node, name) {
+  const flags = ts7.getCombinedModifierFlags(node);
+  if ((flags & (ts7.ModifierFlags.Private | ts7.ModifierFlags.Readonly)) === 0 || !ts7.isClassLike(node.parent)) return false;
+  let written = false;
+  const visit = (child) => {
+    if (written || child === node) return;
+    written = nodeWritesThisProperty(child, name);
+    if (!written) ts7.forEachChild(child, visit);
+  };
+  visit(node.parent);
+  return !written;
+}
+function collectPropertyInstance(collection, node) {
+  if (!ts7.isPropertyDeclaration(node)) return;
+  const initializer = node.initializer;
+  if (!initializer || !ts7.isNewExpression(initializer) || !ts7.isIdentifier(initializer.expression)) return;
+  const name = propertyName2(node.name);
+  if (name && stableProperty(node, name)) rememberInstance(
+    collection,
+    node.name,
+    initializer.expression,
+    name
+  );
+}
+function collectDerivedSymbolContexts(collection) {
+  const visit = (node) => {
+    collectProxy(collection, node);
+    collectVariableInstance(collection, node);
+    collectPropertyInstance(collection, node);
+    ts7.forEachChild(node, visit);
+  };
+  visit(collection.source);
+}
+
+// src/parsers/symbol-parser.ts
+function lineOf2(source, pos) {
+  return source.getLineAndCharacterOfPosition(pos).line + 1;
+}
+function nameOf(node) {
+  if (!node) return void 0;
+  if (ts8.isIdentifier(node) || ts8.isStringLiteral(node) || ts8.isNumericLiteral(node)) return node.text;
+  return void 0;
+}
+function isFunctionLike(node) {
+  return ts8.isFunctionDeclaration(node) || ts8.isMethodDeclaration(node) || ts8.isFunctionExpression(node) || ts8.isArrowFunction(node);
+}
+function exported(node) {
+  return Boolean(ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Export);
+}
+function isPublicClassMethod(node) {
+  const flags = ts8.getCombinedModifierFlags(node);
+  return (flags & ts8.ModifierFlags.Private) === 0 && (flags & ts8.ModifierFlags.Protected) === 0;
+}
+function exportDeclarations(source) {
+  const exports = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts8.isExportDeclaration(node) && node.exportClause && ts8.isNamedExports(node.exportClause)) {
+      for (const el of node.exportClause.elements) exports.set((el.propertyName ?? el.name).text, el.name.text);
+    }
+    ts8.forEachChild(node, visit);
+  };
+  visit(source);
+  return exports;
+}
+function isObjectFunction(node) {
+  return ts8.isFunctionExpression(node) || ts8.isArrowFunction(node) || ts8.isMethodDeclaration(node);
+}
+function requireSource(expr) {
+  if (!ts8.isCallExpression(expr) || !ts8.isIdentifier(expr.expression) || expr.expression.text !== "require") return void 0;
+  const first = expr.arguments[0];
+  return first && ts8.isStringLiteral(first) ? first.text : void 0;
+}
 function bindingLocalName(name, initializer) {
-  if (ts.isIdentifier(name)) return name.text;
-  if (initializer && ts.isIdentifier(initializer)) return initializer.text;
+  if (ts8.isIdentifier(name)) return name.text;
+  if (initializer && ts8.isIdentifier(initializer)) return initializer.text;
   return void 0;
 }
 function objectPatternAliases(pattern, parameter, source, lineNode) {
   return pattern.elements.flatMap((element) => {
-    if (element.dotDotDotToken || ts.isObjectBindingPattern(element.name) || ts.isArrayBindingPattern(element.name)) return [];
+    if (element.dotDotDotToken || ts8.isObjectBindingPattern(element.name) || ts8.isArrayBindingPattern(element.name)) return [];
     const property = element.propertyName ? nameOf(element.propertyName) : nameOf(element.name);
     if (!property) return [];
     const local = bindingLocalName(element.name, element.initializer);
-    return local ? [{ parameter, property, local, kind: "object_parameter_destructure", line: lineOf(source, lineNode.getStart(source)) }] : [];
+    return local ? [{ parameter, property, local, kind: "object_parameter_destructure", line: lineOf2(source, lineNode.getStart(source)) }] : [];
   });
 }
 function parameterPropertyAliases(fn, source) {
-  const parameterNames = new Set(fn.parameters.flatMap((param) => ts.isIdentifier(param.name) ? [param.name.text] : []));
+  const parameterNames = new Set(fn.parameters.flatMap((param) => ts8.isIdentifier(param.name) ? [param.name.text] : []));
   if (!fn.body || parameterNames.size === 0) return [];
   const aliases = [];
   const addFromAssignment = (left, right, node) => {
-    if (!ts.isObjectLiteralExpression(left) || !ts.isIdentifier(right) || !parameterNames.has(right.text)) return;
+    if (!ts8.isObjectLiteralExpression(left) || !ts8.isIdentifier(right) || !parameterNames.has(right.text)) return;
     for (const prop of left.properties) {
-      if (!ts.isPropertyAssignment(prop)) continue;
+      if (!ts8.isPropertyAssignment(prop)) continue;
       const property = nameOf(prop.name);
-      if (property && ts.isIdentifier(prop.initializer)) aliases.push({ parameter: right.text, property, local: prop.initializer.text, kind: "object_parameter_destructure", line: lineOf(source, node.getStart(source)) });
+      if (property && ts8.isIdentifier(prop.initializer)) aliases.push({ parameter: right.text, property, local: prop.initializer.text, kind: "object_parameter_destructure", line: lineOf2(source, node.getStart(source)) });
     }
   };
   const visit = (node) => {
-    if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && ts.isIdentifier(node.initializer) && parameterNames.has(node.initializer.text)) aliases.push(...objectPatternAliases(node.name, node.initializer.text, source, node));
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) addFromAssignment(ts.isParenthesizedExpression(node.left) ? node.left.expression : node.left, node.right, node);
-    ts.forEachChild(node, visit);
+    if (ts8.isVariableDeclaration(node) && ts8.isObjectBindingPattern(node.name) && node.initializer && ts8.isIdentifier(node.initializer) && parameterNames.has(node.initializer.text)) aliases.push(...objectPatternAliases(node.name, node.initializer.text, source, node));
+    if (ts8.isBinaryExpression(node) && node.operatorToken.kind === ts8.SyntaxKind.EqualsToken) addFromAssignment(ts8.isParenthesizedExpression(node.left) ? node.left.expression : node.left, node.right, node);
+    ts8.forEachChild(node, visit);
   };
   visit(fn.body);
   const seen = /* @__PURE__ */ new Set();
@@ -469,10 +1894,10 @@ function parameterPropertyAliases(fn, source) {
 }
 function parameterBindings(params) {
   return params.flatMap((param, index) => {
-    if (ts.isIdentifier(param.name)) return [{ index, kind: "identifier", name: param.name.text }];
-    if (ts.isObjectBindingPattern(param.name)) {
+    if (ts8.isIdentifier(param.name)) return [{ index, kind: "identifier", name: param.name.text }];
+    if (ts8.isObjectBindingPattern(param.name)) {
       const properties = param.name.elements.flatMap((element) => {
-        if (element.dotDotDotToken || ts.isObjectBindingPattern(element.name) || ts.isArrayBindingPattern(element.name)) return [];
+        if (element.dotDotDotToken || ts8.isObjectBindingPattern(element.name) || ts8.isArrayBindingPattern(element.name)) return [];
         const property = element.propertyName ? nameOf(element.propertyName) : nameOf(element.name);
         if (!property) return [];
         const local = bindingLocalName(element.name, element.initializer);
@@ -480,237 +1905,431 @@ function parameterBindings(params) {
       });
       return properties.length > 0 ? [{ index, kind: "object_pattern", properties }] : [];
     }
-    if (ts.isArrayBindingPattern(param.name)) {
-      const elements = param.name.elements.flatMap((element, elementIndex) => ts.isBindingElement(element) && !element.dotDotDotToken && ts.isIdentifier(element.name) ? [{ index: elementIndex, local: element.name.text }] : []);
+    if (ts8.isArrayBindingPattern(param.name)) {
+      const elements = param.name.elements.flatMap((element, elementIndex) => ts8.isBindingElement(element) && !element.dotDotDotToken && ts8.isIdentifier(element.name) ? [{ index: elementIndex, local: element.name.text }] : []);
       return elements.length > 0 ? [{ index, kind: "array_pattern", elements }] : [];
     }
     return [];
   });
 }
-async function parseExecutableSymbols(repoPath, filePath, context) {
-  const snapshot = context?.get(filePath);
-  const text = snapshot?.text ?? await fs4.readFile(path4.join(repoPath, filePath), "utf8");
-  const source = snapshot?.sourceFile() ?? ts.createSourceFile(
-    filePath,
-    text,
-    ts.ScriptTarget.Latest,
-    true,
-    filePath.endsWith(".ts") ? ts.ScriptKind.TS : ts.ScriptKind.JS
+function symbolSourceEvidence(collection, node, options) {
+  if (options.evidence) return options.evidence;
+  if (options.classMemberExported) return {
+    source: "exported_class_member",
+    exportedClass: options.parentRoot,
+    memberKind: ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Static ? "static_method" : "class_method"
+  };
+  if (options.classContainerExported && ts8.isMethodDeclaration(node) && isPublicClassMethod(node)) return {
+    source: "exported_class_instance_member",
+    exportedClass: options.parentRoot,
+    memberKind: "class_method"
+  };
+  if (options.declaredExportName) return {
+    exportedName: options.declaredExportName,
+    source: "export_declaration"
+  };
+  return options.objectExported ? { exportedName: options.qualifiedName, source: "exported_object_literal" } : {};
+}
+function executableEvidence(node, source) {
+  if (!isFunctionLike(node)) return {};
+  const bindings = parameterBindings(node.parameters);
+  const parameters = bindings.flatMap((binding) => binding.kind === "identifier" ? [binding.name] : []);
+  const aliases = parameterPropertyAliases(node, source);
+  return {
+    executableBodyEligibility: executableBodyEligibility(node, source),
+    ...bindings.length > 0 ? { parameters, parameterBindings: bindings } : {},
+    ...aliases.length > 0 ? { parameterPropertyAliases: aliases } : {}
+  };
+}
+function exportedClassMember(collection, kind, parentName, parentRoot, node) {
+  if (kind !== "method" || !parentName || !collection.exportedClasses.has(parentRoot) || !ts8.isMethodDeclaration(node)) return false;
+  return Boolean(ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Static) && isPublicClassMethod(node);
+}
+function symbolNames(collection, kind, localName, node, parentName, exportedName) {
+  const parentRoot = parentName?.split(".")[0] ?? "";
+  const declaredExportName = exportedName ?? collection.exportNames.get(
+    parentName ? parentRoot : localName
   );
-  const sourceFile = normalizePath(filePath);
-  const symbols = [];
-  const calls = [];
-  const imports = /* @__PURE__ */ new Map();
-  const namespaceImports = /* @__PURE__ */ new Set();
-  const eventSubscriptionOffsets = new Set(
-    classifyOutboundCallsInSource(source, sourceFile).filter((call) => call.fact.callType === "async_subscribe").map((call) => `${call.node.getStart(source)}:${call.node.getEnd()}`)
-  );
-  const exportNames = exportDeclarations(source);
-  const objectExports = /* @__PURE__ */ new Set();
-  const exportedClasses = /* @__PURE__ */ new Set();
-  const declaredClasses = /* @__PURE__ */ new Set();
-  const proxyVariables = /* @__PURE__ */ new Map();
-  const classInstances = /* @__PURE__ */ new Map();
-  const addSymbol = (kind, localName, node, parentName, exportedName, evidence) => {
-    const parentRoot = parentName?.split(".")[0] ?? "";
-    const declaredExportName = exportedName ?? exportNames.get(parentName ? parentRoot : localName);
-    const qualifiedName = parentName ? `${parentName}.${localName}` : localName;
-    const objectExported = parentName ? objectExports.has(parentRoot) : false;
-    const classMemberExported = kind === "method" && parentName ? exportedClasses.has(parentRoot) && ts.isMethodDeclaration(node) && (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Static) !== 0 && isPublicClassMethod(node) : false;
-    const effectiveExportedName = classMemberExported || objectExported ? qualifiedName : declaredExportName;
-    const bindings = isFunctionLike(node) ? parameterBindings(node.parameters) : void 0;
-    const params = bindings?.flatMap((binding) => binding.kind === "identifier" ? [binding.name] : []);
-    const sourceEvidence = evidence ?? (classMemberExported ? { source: "exported_class_member", exportedClass: parentRoot, memberKind: (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Static) !== 0 ? "static_method" : "class_method", parameters: params } : declaredExportName ? { exportedName: declaredExportName, source: "export_declaration" } : objectExported ? { exportedName: qualifiedName, source: "exported_object_literal" } : void 0);
-    const aliases = isFunctionLike(node) ? parameterPropertyAliases(node, source) : [];
-    const parameterEvidence = { ...bindings && bindings.length > 0 ? { parameters: params, parameterBindings: bindings } : {}, ...aliases.length > 0 ? { parameterPropertyAliases: aliases } : {} };
-    symbols.push({ kind, localName: kind === "object_method" ? qualifiedName : localName, exportedName: effectiveExportedName, qualifiedName, sourceFile, startLine: lineOf(source, node.getStart(source)), endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: exported(node) || Boolean(effectiveExportedName), importExportEvidence: sourceEvidence ? { ...sourceEvidence, ...parameterEvidence } : bindings && bindings.length > 0 ? parameterEvidence : void 0 });
-  };
-  const addAliasSymbol = (objectName, propertyName, node, targetImportSource) => {
-    symbols.push({ kind: "object_alias", localName: propertyName, exportedName: propertyName, qualifiedName: `${objectName}.${propertyName}`, sourceFile, startLine: lineOf(source, node.getStart(source)), endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: true, importExportEvidence: { source: "exported_object_shorthand", objectName, propertyName, targetImportSource } });
-  };
-  const visitImports = (node) => {
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-      const sourceText = node.moduleSpecifier.text;
-      const clause = node.importClause;
-      if (clause?.name) imports.set(clause.name.text, sourceText);
-      const named = clause?.namedBindings;
-      if (named && ts.isNamedImports(named)) for (const el of named.elements) imports.set(el.name.text, sourceText);
-      if (named && ts.isNamespaceImport(named)) {
-        imports.set(named.name.text, sourceText);
-        namespaceImports.add(named.name.text);
-      }
+  const qualifiedName = parentName ? `${parentName}.${localName}` : localName;
+  const objectExported = Boolean(
+    parentName && collection.objectExports.has(parentRoot)
+  );
+  const classMemberExported = exportedClassMember(
+    collection,
+    kind,
+    parentName,
+    parentRoot,
+    node
+  );
+  const classContainerExported = Boolean(
+    parentName && collection.exportedClasses.has(parentRoot)
+  );
+  return {
+    parentRoot,
+    declaredExportName,
+    qualifiedName,
+    objectExported,
+    classContainerExported,
+    classMemberExported,
+    effectiveName: classMemberExported || objectExported ? qualifiedName : declaredExportName
+  };
+}
+function addExecutableSymbol(collection, kind, localName, node, parentName, exportedName, evidence) {
+  const names = symbolNames(
+    collection,
+    kind,
+    localName,
+    node,
+    parentName,
+    exportedName
+  );
+  const sourceEvidence = symbolSourceEvidence(collection, node, {
+    parentRoot: names.parentRoot,
+    qualifiedName: names.qualifiedName,
+    declaredExportName: names.declaredExportName,
+    classContainerExported: names.classContainerExported,
+    classMemberExported: names.classMemberExported,
+    objectExported: names.objectExported,
+    evidence
+  });
+  collection.symbols.push({
+    kind,
+    localName: kind === "object_method" ? names.qualifiedName : localName,
+    exportedName: names.effectiveName,
+    qualifiedName: names.qualifiedName,
+    sourceFile: collection.sourceFile,
+    startLine: lineOf2(collection.source, node.getStart(collection.source)),
+    endLine: lineOf2(collection.source, node.getEnd()),
+    startOffset: node.getStart(collection.source),
+    endOffset: node.getEnd(),
+    exported: exported(node) || Boolean(names.effectiveName),
+    importExportEvidence: {
+      ...sourceEvidence,
+      ...executableEvidence(node, collection.source)
     }
-    if (ts.isVariableStatement(node)) {
-      for (const declaration of node.declarationList.declarations) {
-        const requiredSource = declaration.initializer ? requireSource(declaration.initializer) : void 0;
-        if (ts.isIdentifier(declaration.name) && requiredSource) imports.set(declaration.name.text, requiredSource);
-        if (ts.isObjectBindingPattern(declaration.name) && requiredSource) {
-          for (const element of declaration.name.elements) if (ts.isIdentifier(element.name)) imports.set(element.name.text, requiredSource);
-        }
-      }
+  });
+}
+function addAliasSymbol(collection, objectName, propertyName3, node) {
+  collection.symbols.push({
+    kind: "object_alias",
+    localName: propertyName3,
+    exportedName: propertyName3,
+    qualifiedName: `${objectName}.${propertyName3}`,
+    sourceFile: collection.sourceFile,
+    startLine: lineOf2(collection.source, node.getStart(collection.source)),
+    endLine: lineOf2(collection.source, node.getEnd()),
+    startOffset: node.getStart(collection.source),
+    endOffset: node.getEnd(),
+    exported: true,
+    importExportEvidence: {
+      source: "exported_object_shorthand",
+      objectName,
+      propertyName: propertyName3,
+      targetImportSource: collection.imports.get(propertyName3)
     }
-    ts.forEachChild(node, visitImports);
-  };
-  visitImports(source);
-  const visitSymbols = (node, parentClass) => {
-    if (ts.isClassDeclaration(node) && node.name) {
-      declaredClasses.add(node.name.text);
-      if (exported(node) || exportNames.has(node.name.text)) exportedClasses.add(node.name.text);
-      for (const member of node.members) visitSymbols(member, node.name.text);
-      return;
+  });
+}
+function collectImportSources(collection) {
+  const visit = (node) => {
+    if (ts8.isImportDeclaration(node) && ts8.isStringLiteral(node.moduleSpecifier))
+      collectEsmImportSources(collection.imports, node);
+    if (ts8.isVariableStatement(node))
+      collectCjsImportSources(collection.imports, node);
+    ts8.forEachChild(node, visit);
+  };
+  visit(collection.source);
+}
+function collectEsmImportSources(imports, node) {
+  if (!ts8.isStringLiteral(node.moduleSpecifier)) return;
+  const source = node.moduleSpecifier.text;
+  const clause = node.importClause;
+  if (clause?.name) imports.set(clause.name.text, source);
+  const named = clause?.namedBindings;
+  if (named && ts8.isNamedImports(named))
+    for (const item of named.elements) imports.set(item.name.text, source);
+  if (named && ts8.isNamespaceImport(named))
+    imports.set(named.name.text, source);
+}
+function collectCjsImportSources(imports, node) {
+  for (const declaration of node.declarationList.declarations) {
+    const source = declaration.initializer ? requireSource(declaration.initializer) : void 0;
+    if (!source) continue;
+    if (ts8.isIdentifier(declaration.name))
+      imports.set(declaration.name.text, source);
+    if (ts8.isObjectBindingPattern(declaration.name)) {
+      for (const item of declaration.name.elements)
+        if (ts8.isIdentifier(item.name)) imports.set(item.name.text, source);
     }
-    if (ts.isMethodDeclaration(node)) {
-      const localName = nameOf(node.name);
-      if (localName) addSymbol("method", localName, node, parentClass);
-    } else if (ts.isPropertyDeclaration(node) && parentClass && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
-      const localName = nameOf(node.name);
-      if (localName) {
-        const flags = ts.getCombinedModifierFlags(node);
-        const staticPublicExported = exportedClasses.has(parentClass) && (flags & ts.ModifierFlags.Static) !== 0 && (flags & ts.ModifierFlags.Private) === 0 && (flags & ts.ModifierFlags.Protected) === 0;
-        const isArrow = ts.isArrowFunction(node.initializer);
-        const memberKind = isArrow ? staticPublicExported ? "static_arrow_function" : "arrow_function_property" : staticPublicExported ? "static_function_expression" : "function_expression_property";
-        addSymbol("method", localName, node.initializer, parentClass, staticPublicExported ? `${parentClass}.${localName}` : void 0, staticPublicExported ? { source: "exported_class_member", exportedClass: parentClass, memberKind } : { source: "class_property_function", memberKind });
-      }
-    } else if (ts.isFunctionDeclaration(node) && node.name) addSymbol("function", node.name.text, node, void 0, exported(node) ? node.name.text : void 0);
-    else if (ts.isVariableStatement(node)) {
-      for (const d of node.declarationList.declarations) {
-        const localName = nameOf(d.name);
-        if (!localName || !d.initializer) continue;
-        if (isFunctionLike(d.initializer)) addSymbol("function", localName, d.initializer, void 0, exported(node) ? localName : exportNames.get(localName));
-        if (ts.isObjectLiteralExpression(d.initializer)) {
-          const objectIsExported = exported(node) || exportNames.has(localName);
-          if (objectIsExported) objectExports.add(localName);
-          for (const prop of d.initializer.properties) {
-            if (objectIsExported && ts.isShorthandPropertyAssignment(prop)) addAliasSymbol(localName, prop.name.text, prop.name, imports.get(prop.name.text));
-            if (ts.isPropertyAssignment(prop) && isObjectFunction(prop.initializer)) {
-              const propName = nameOf(prop.name);
-              if (propName) addSymbol("object_method", propName, prop.initializer, localName);
-            } else if (ts.isMethodDeclaration(prop)) {
-              const propName = nameOf(prop.name);
-              if (propName) addSymbol("object_method", propName, prop, localName);
-            }
-          }
-        }
-      }
-    } else ts.forEachChild(node, (child) => visitSymbols(child, parentClass));
-  };
-  visitSymbols(source);
-  const isTopLevelCallback = (node) => {
-    if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) return false;
-    if (!ts.isCallExpression(node.parent)) return false;
-    const callee = callName(node.parent.expression);
-    const member = callee.member ?? callee.local;
-    return Boolean(member && ["bootstrap", "served", "connect", "on", "once", "use", "get", "post", "put", "patch", "delete", "subscribe"].includes(member));
-  };
-  const visitCallbackSymbols = (node) => {
-    if (isTopLevelCallback(node) && containsSupportedOutboundCall(node)) {
-      const startLine = lineOf(source, node.getStart(source));
+  }
+}
+function classPropertySymbol(collection, node, parentClass) {
+  const initializer = node.initializer;
+  const localName = nameOf(node.name);
+  if (!localName || !initializer || !ts8.isArrowFunction(initializer) && !ts8.isFunctionExpression(initializer)) return;
+  const staticPublic = publicStaticProperty(collection, node, parentClass);
+  const memberKind = propertyMemberKind(initializer, staticPublic);
+  addExecutableSymbol(
+    collection,
+    "method",
+    localName,
+    initializer,
+    parentClass,
+    staticPublic ? `${parentClass}.${localName}` : void 0,
+    staticPublic ? { source: "exported_class_member", exportedClass: parentClass, memberKind } : { source: "class_property_function", memberKind }
+  );
+}
+function publicStaticProperty(collection, node, parentClass) {
+  const flags = ts8.getCombinedModifierFlags(node);
+  return collection.exportedClasses.has(parentClass) && Boolean(flags & ts8.ModifierFlags.Static) && (flags & ts8.ModifierFlags.Private) === 0 && (flags & ts8.ModifierFlags.Protected) === 0;
+}
+function propertyMemberKind(initializer, staticPublic) {
+  if (ts8.isArrowFunction(initializer))
+    return staticPublic ? "static_arrow_function" : "arrow_function_property";
+  return staticPublic ? "static_function_expression" : "function_expression_property";
+}
+function objectCallable(property) {
+  if (ts8.isMethodDeclaration(property)) return property;
+  return ts8.isPropertyAssignment(property) && isObjectFunction(property.initializer) ? property.initializer : void 0;
+}
+function objectLiteralSymbols(collection, objectName, object, objectIsExported) {
+  if (objectIsExported) collection.objectExports.add(objectName);
+  for (const property of object.properties) {
+    if (objectIsExported && ts8.isShorthandPropertyAssignment(property))
+      addAliasSymbol(collection, objectName, property.name.text, property.name);
+    const callable = objectCallable(property);
+    const propertyName3 = callable ? nameOf(property.name) : void 0;
+    if (callable && propertyName3)
+      addExecutableSymbol(
+        collection,
+        "object_method",
+        propertyName3,
+        callable,
+        objectName
+      );
+  }
+}
+function variableSymbols(collection, node) {
+  for (const declaration of node.declarationList.declarations) {
+    const localName = nameOf(declaration.name);
+    const initializer = declaration.initializer;
+    if (!localName || !initializer) continue;
+    if (isFunctionLike(initializer)) addExecutableSymbol(
+      collection,
+      "function",
+      localName,
+      initializer,
+      void 0,
+      exported(node) ? localName : collection.exportNames.get(localName)
+    );
+    if (ts8.isObjectLiteralExpression(initializer))
+      objectLiteralSymbols(
+        collection,
+        localName,
+        initializer,
+        exported(node) || collection.exportNames.has(localName)
+      );
+  }
+}
+function collectClassDeclaration(collection, node) {
+  if (!ts8.isClassDeclaration(node) || !node.name) return false;
+  collection.declaredClasses.add(node.name.text);
+  if (exported(node) || collection.exportNames.has(node.name.text))
+    collection.exportedClasses.add(node.name.text);
+  for (const member of node.members)
+    visitDeclaredSymbol(collection, member, node.name.text);
+  return true;
+}
+function collectMethodDeclaration(collection, node, parentClass) {
+  if (!ts8.isMethodDeclaration(node)) return false;
+  const localName = nameOf(node.name);
+  if (localName)
+    addExecutableSymbol(collection, "method", localName, node, parentClass);
+  return true;
+}
+function visitDeclaredSymbol(collection, node, parentClass) {
+  if (collectClassDeclaration(collection, node)) return;
+  if (collectMethodDeclaration(collection, node, parentClass)) return;
+  if (ts8.isPropertyDeclaration(node)) {
+    if (parentClass) classPropertySymbol(collection, node, parentClass);
+    return;
+  }
+  if (ts8.isFunctionDeclaration(node) && node.name) {
+    addExecutableSymbol(
+      collection,
+      "function",
+      node.name.text,
+      node,
+      void 0,
+      exported(node) ? node.name.text : void 0
+    );
+    return;
+  }
+  if (ts8.isVariableStatement(node)) {
+    variableSymbols(collection, node);
+    return;
+  }
+  ts8.forEachChild(node, (child) => visitDeclaredSymbol(collection, child, parentClass));
+}
+function collectDeclaredSymbols(collection) {
+  visitDeclaredSymbol(collection, collection.source);
+}
+function isTopLevelCallback(node) {
+  if (!ts8.isArrowFunction(node) && !ts8.isFunctionExpression(node) || !ts8.isCallExpression(node.parent)) return false;
+  const callee = symbolCallName(node.parent.expression);
+  const member = callee.member ?? callee.local;
+  return Boolean(member && [
+    "bootstrap",
+    "served",
+    "connect",
+    "on",
+    "once",
+    "use",
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "subscribe"
+  ].includes(member));
+}
+function collectCallbackSymbols(collection) {
+  const visit = (node) => {
+    if (isTopLevelCallback(node) && containsSupportedOutboundCall(node, collection.classifiedCalls)) {
+      const startLine = lineOf2(
+        collection.source,
+        node.getStart(collection.source)
+      );
       const name = `callback:${startLine}`;
-      symbols.push({ kind: "callback", localName: name, qualifiedName: `module:${sourceFile}#${name}`, sourceFile, startLine, endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: false, importExportEvidence: { source: "synthetic_outbound_callback", callbackLine: startLine } });
-    }
-    ts.forEachChild(node, visitCallbackSymbols);
-  };
-  visitCallbackSymbols(source);
-  const visitEventRegistrationSymbols = (node) => {
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "on") {
-      const receiver = node.expression.expression.getText(source);
-      const eventArg = node.arguments[0];
-      if ((receiver === "cds" || /^(srv|service|serviceClient|messaging|messageClient|eventClient|.*Client)$/.test(receiver)) && eventArg && (ts.isStringLiteral(eventArg) || ts.isNoSubstitutionTemplateLiteral(eventArg))) {
-        const startLine = lineOf(source, node.getStart(source));
-        const eventName = eventArg.text.replace(/[^A-Za-z0-9_$-]/g, "_");
-        const name = `event:${eventName}:${startLine}`;
-        symbols.push({ kind: "event_registration", localName: name, qualifiedName: `module:${sourceFile}#${name}`, sourceFile, startLine, endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: false, importExportEvidence: { source: "synthetic_event_registration", eventName: eventArg.text, registrationLine: startLine, receiver } });
-      }
-      if (eventSubscriptionOffsets.has(`${node.getStart(source)}:${node.getEnd()}`)) {
-        const startLine = lineOf(source, node.getStart(source));
-        const handlerArgument = node.arguments[1];
-        const target = handlerArgument ? handlerReferenceTarget(
-          handlerArgument,
-          source,
-          imports,
-          namespaceImports
-        ) : void 0;
-        const anchor = nearest(symbols, startLine);
-        if (target && anchor) calls.push({
-          callerQualifiedName: anchor.qualifiedName,
-          calleeExpression: target.calleeExpression,
-          calleeLocalName: target.calleeLocalName,
-          importSource: target.importSource,
-          sourceFile,
-          sourceLine: startLine,
-          callSiteStartOffset: node.getStart(source),
-          callSiteEndOffset: node.getEnd(),
-          callRole: "event_subscribe_handler",
-          evidence: {
-            relation: target.relation,
-            caller: anchor.qualifiedName,
-            targetName: target.calleeLocalName,
-            ...target.wrapperFunction ? { wrapperFunction: target.wrapperFunction } : {},
-            factOrigin: "event_subscribe_handler_reference"
-          }
-        });
-      }
-    }
-    ts.forEachChild(node, visitEventRegistrationSymbols);
-  };
-  visitEventRegistrationSymbols(source);
-  const visitProxyVariables = (node) => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isCallExpression(node.initializer) && ts.isPropertyAccessExpression(node.initializer.expression)) {
-      const callee = callName(node.initializer.expression);
-      const importSource = callee.local ? imports.get(callee.local) : void 0;
-      if (callee.member && importSource && isRelativeImport(importSource)) proxyVariables.set(node.name.text, { importSource, factory: callee.expression, variableName: node.name.text });
+      collection.symbols.push({
+        kind: "callback",
+        localName: name,
+        qualifiedName: `module:${collection.sourceFile}#${name}`,
+        sourceFile: collection.sourceFile,
+        startLine,
+        endLine: lineOf2(collection.source, node.getEnd()),
+        startOffset: node.getStart(collection.source),
+        endOffset: node.getEnd(),
+        exported: false,
+        importExportEvidence: {
+          source: "synthetic_outbound_callback",
+          callbackLine: startLine
+        }
+      });
     }
-    ts.forEachChild(node, visitProxyVariables);
+    ts8.forEachChild(node, visit);
   };
-  visitProxyVariables(source);
-  const rememberClassInstance = (variableName, className, propertyName) => {
-    const importSource = imports.get(className);
-    if (!builtInConstructors.has(className) && (importSource && isRelativeImport(importSource) || declaredClasses.has(className))) classInstances.set(variableName, { className, importSource, propertyName });
+  visit(collection.source);
+}
+function createCollection(source, sourceFile2, classifiedCalls) {
+  return {
+    source,
+    sourceFile: sourceFile2,
+    classifiedCalls,
+    symbols: [],
+    imports: /* @__PURE__ */ new Map(),
+    importBindings: collectSymbolImportBindings(source),
+    exportNames: exportDeclarations(source),
+    objectExports: /* @__PURE__ */ new Set(),
+    exportedClasses: /* @__PURE__ */ new Set(),
+    declaredClasses: /* @__PURE__ */ new Set(),
+    proxies: /* @__PURE__ */ new Map(),
+    instances: /* @__PURE__ */ new Map()
   };
-  const visitClassInstances = (node) => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isNewExpression(node.initializer) && ts.isIdentifier(node.initializer.expression)) {
-      rememberClassInstance(node.name.text, node.initializer.expression.text);
-    }
-    if (ts.isPropertyDeclaration(node) && node.initializer && ts.isNewExpression(node.initializer) && ts.isIdentifier(node.initializer.expression)) {
-      const propertyName = nameOf(node.name);
-      if (propertyName) rememberClassInstance(`this.${propertyName}`, node.initializer.expression.text, propertyName);
-    }
-    ts.forEachChild(node, visitClassInstances);
-  };
-  visitClassInstances(source);
-  const localCallables = new Set(symbols.flatMap((sym) => [sym.localName, sym.qualifiedName]));
-  const visitCalls = (node) => {
-    if (ts.isCallExpression(node)) {
-      const line = lineOf(source, node.getStart(source));
-      const caller = nearest(symbols, line);
-      if (caller) {
-        const callee = callName(node.expression);
-        const proxy = callee.local ? proxyVariables.get(callee.local) : void 0;
-        const instance = (callee.local ? classInstances.get(callee.local) : void 0) ?? (callee.receiver ? classInstances.get(callee.receiver) : void 0);
-        const importSource = instance?.importSource ?? proxy?.importSource ?? (callee.local ? imports.get(callee.local) : void 0) ?? (callee.member && callee.local ? imports.get(callee.local) : void 0);
-        const directThisMethod = callee.receiver === "this";
-        const namespaceMember = Boolean(callee.member && callee.local && namespaceImports.has(callee.local));
-        const packageImport = Boolean(importSource && !isRelativeImport(importSource));
-        const targetName = instance && callee.member ? `${instance.className}.${callee.member}` : proxy && callee.member ? callee.member : directThisMethod ? callee.member : namespaceMember ? callee.member : packageImport ? callee.member ?? callee.local : callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
-        const className = caller.qualifiedName.includes(".") ? caller.qualifiedName.split(".")[0] : void 0;
-        const thisTarget = directThisMethod && className && callee.member ? `${className}.${callee.member}` : void 0;
-        const loggerLike = callee.receiver?.endsWith(".logger") || callee.local === "logger" || (callee.expression.startsWith("this.logger.") && callee.member ? loggerMembers.has(callee.member) : false);
-        const terminalMember = callee.member ? commonTerminalMembers.has(callee.member) || loggerMembers.has(callee.member) : false;
-        const provenLocal = Boolean(targetName) && localCallables.has(String(targetName));
-        const provenThisMethod = Boolean(thisTarget && localCallables.has(thisTarget));
-        const provenRelativeImport = Boolean(isRelativeImport(importSource) && targetName);
-        const provenClassInstance = Boolean(instance && callee.member && targetName);
-        const provenPackageImport = Boolean(packageImport && targetName);
-        const ignored = loggerLike || terminalMember || ignoredFrameworkCall(callee);
-        const resolvedTarget = provenThisMethod ? thisTarget : targetName;
-        const keep = Boolean(resolvedTarget) && !ignored && (provenLocal || provenThisMethod || provenRelativeImport || provenClassInstance || provenPackageImport);
-        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: resolvedTarget, receiverLocalName: callee.member ? callee.local ?? callee.receiver : void 0, importSource, sourceFile, sourceLine: line, callSiteStartOffset: node.getStart(source), callSiteEndOffset: node.getEnd(), callRole: "ordinary_call", evidence: { relation: instance ? "class_instance_method" : proxy ? "relative_import_proxy_member" : packageImport ? "package_import" : namespaceMember ? "relative_import_namespace_member" : importSource ? "relative_import" : provenThisMethod ? "indexed_this_method" : "indexed_local_symbol", caller: caller.qualifiedName, targetName: resolvedTarget, instanceVariable: instance ? instance.propertyName ?? callee.local : void 0, className: instance?.className, methodName: instance ? callee.member : void 0, classImportSource: instance?.importSource, callArguments: argumentEvidence(node.arguments, source), proxyVariableName: proxy?.variableName, factory: proxy?.factory, factoryExpression: proxy?.factory, factoryImportSource: proxy?.importSource, candidateStrategy: instance ? instance.importSource ? "relative_import_class_instance_method" : "same_file_class_instance_method" : proxy ? "proxy_member_exact_export_or_unique_member" : void 0 } });
-      }
-    }
-    ts.forEachChild(node, visitCalls);
+}
+function populateCollection(collection) {
+  collectImportSources(collection);
+  collectDeclaredSymbols(collection);
+  collectCallbackSymbols(collection);
+  collectDerivedSymbolContexts(collection);
+}
+async function sourceFile(repoPath, filePath, context) {
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text ?? await fs4.readFile(path4.join(repoPath, filePath), "utf8");
+  return snapshot?.sourceFile() ?? ts8.createSourceFile(
+    filePath,
+    text,
+    ts8.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS
+  );
+}
+async function parseExecutableSymbols(repoPath, filePath, context, preparedOutboundCalls) {
+  const source = await sourceFile(repoPath, filePath, context);
+  const normalizedFile = normalizePath(filePath);
+  const classified = preparedOutboundCalls ?? classifyOutboundCallsInSource(source, normalizedFile);
+  const collection = createCollection(source, normalizedFile, classified);
+  populateCollection(collection);
+  const calls = collectSymbolCallFacts({
+    source,
+    sourceFile: normalizedFile,
+    symbols: collection.symbols,
+    imports: collection.imports,
+    importBindings: collection.importBindings,
+    proxies: collection.proxies,
+    instances: collection.instances
+  });
+  const events = reconcileEventSubscriptions(
+    source,
+    classified,
+    collection.symbols,
+    calls
+  );
+  return {
+    symbols: events.symbols,
+    calls: reconcileSymbolCallOwners(events.calls, events.symbols)
   };
-  visitCalls(source);
-  return { symbols, calls };
+}
+
+// src/parsers/008-package-surface-publication.ts
+function symbolIdentity(symbol) {
+  return [
+    symbol.sourceFile,
+    symbol.kind,
+    symbol.qualifiedName,
+    symbol.startOffset,
+    symbol.endOffset
+  ].join("\0");
+}
+function exposureBySymbol(analysis) {
+  return new Map(analysis.symbols.map((item) => [
+    symbolIdentity({
+      sourceFile: item.target.sourceFile,
+      kind: item.target.kind,
+      qualifiedName: item.target.qualifiedName,
+      startOffset: item.target.startOffset,
+      endOffset: item.target.endOffset
+    }),
+    item
+  ]));
+}
+function analyzeRepositoryPackageSurface(facts, manifest, sources) {
+  const modules = sources.entries().filter((snapshot) => /\.[jt]s$/.test(snapshot.filePath)).map((snapshot) => ({
+    sourceFile: normalizePath(snapshot.filePath),
+    source: snapshot.sourceFile()
+  }));
+  return analyzePackagePublicSurface(facts.packageName, manifest, modules);
+}
+function mergePackageSymbolEvidence(symbols, analysis) {
+  const exposures = exposureBySymbol(analysis);
+  return symbols.map((symbol) => {
+    const exposure = exposures.get(symbolIdentity(symbol));
+    if (!exposure) return symbol;
+    return {
+      ...symbol,
+      importExportEvidence: {
+        ...symbol.importExportEvidence ?? {},
+        packagePublicSurface: {
+          schema: analysis.surface.schema,
+          recordCap: analysis.surface.recordCap,
+          bodyEligibility: exposure.target.bodyEligibility,
+          exposures: exposure.exposures,
+          exposureTotal: exposure.exposureTotal,
+          shownExposureCount: exposure.shownExposureCount,
+          omittedExposureCount: exposure.omittedExposureCount
+        }
+      }
+    };
+  });
 }
 
 // src/utils/hashing.ts
@@ -720,6 +2339,130 @@ function sha256Text(text) {
   return createHash("sha256").update(text).digest("hex");
 }
 
+// src/db/004-package-target-invalidation.ts
+var resolverKeys = /* @__PURE__ */ new Set([
+  "candidateStrategy",
+  "candidateCount",
+  "eligibleCandidateCount",
+  "selectedCandidateCount",
+  "candidateSetComplete",
+  "resolvedModulePath",
+  "resolvedTargetRepositoryId",
+  "unresolvedReason",
+  "targetRepositoryCandidateCount",
+  "targetRepositoryCandidates",
+  "shownTargetRepositoryCandidateCount",
+  "omittedTargetRepositoryCandidateCount",
+  "publicSurface"
+]);
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parsedEvidence(value) {
+  if (typeof value !== "string") return void 0;
+  try {
+    return record(JSON.parse(value));
+  } catch {
+    return void 0;
+  }
+}
+function packageName(evidence) {
+  return parsePackageImportReference(evidence.importBinding)?.requestedPackageName ?? void 0;
+}
+function packageCallEvidenceValid(evidence) {
+  const binding = record(evidence.importBinding);
+  const classified = evidence.relation === "package_import" || binding?.moduleKind === "package";
+  return !classified || packageName(evidence) !== void 0;
+}
+function currentCalls(db, workspaceId, targetRepoId) {
+  const rows = db.prepare(`SELECT sc.id,sc.repo_id repoId,
+    sc.evidence_json evidenceJson FROM symbol_calls sc
+    JOIN repositories r ON r.id=sc.repo_id
+    WHERE r.workspace_id=? AND r.id<>? AND r.fact_analyzer_version=?
+    ORDER BY sc.id`).all(workspaceId, targetRepoId, ANALYZER_VERSION);
+  return rows.flatMap((row) => {
+    const evidence = parsedEvidence(row.evidenceJson);
+    if (!evidence || typeof row.id !== "number" || typeof row.repoId !== "number")
+      throw new Error("invalid_current_package_import_evidence");
+    if (!packageCallEvidenceValid(evidence))
+      throw new Error("invalid_current_package_import_evidence");
+    return evidence.relation === "package_import" || record(evidence.importBinding)?.moduleKind === "package" ? [{ id: row.id, repoId: row.repoId, evidence }] : [];
+  });
+}
+function pendingEvidence(evidence) {
+  const parser = Object.fromEntries(Object.entries(evidence).filter(
+    ([key]) => !resolverKeys.has(key)
+  ));
+  if (!packageName(parser))
+    throw new Error("invalid_current_package_import_evidence");
+  return JSON.stringify({
+    ...parser,
+    candidateStrategy: "package_import_pending",
+    candidateCount: 0,
+    eligibleCandidateCount: 0,
+    selectedCandidateCount: 0,
+    candidateSetComplete: false,
+    unresolvedReason: "package_resolution_pending"
+  });
+}
+function targetWorkspace(db, repoId) {
+  const row = db.prepare(`SELECT workspace_id workspaceId,
+    package_name packageName FROM repositories WHERE id=?`).get(repoId);
+  if (typeof row?.workspaceId !== "number")
+    throw new Error("Repository target is missing its workspace");
+  return {
+    workspaceId: row.workspaceId,
+    packageName: typeof row.packageName === "string" || row.packageName === null ? row.packageName : void 0
+  };
+}
+function packageIdentityChanged(previous, next) {
+  const previousName = typeof previous === "string" ? previous : null;
+  const nextName = typeof next === "string" ? next : null;
+  return previousName !== nextName;
+}
+function invalidatePackageTargetFacts(db, targetRepoId, newPackageName, batch) {
+  const target = targetWorkspace(db, targetRepoId);
+  const names = new Set(
+    [target.packageName, newPackageName].filter(
+      (value) => typeof value === "string" && value.length > 0
+    )
+  );
+  if (names.size === 0) return;
+  const update = db.prepare(`UPDATE symbol_calls SET callee_symbol_id=NULL,
+    status='unresolved',unresolved_reason='package_resolution_pending',
+    evidence_json=? WHERE id=?`);
+  let matched = false;
+  for (const call of currentCalls(db, target.workspaceId, targetRepoId)) {
+    const requested = packageName(call.evidence);
+    if (!requested || !names.has(requested)) continue;
+    update.run(pendingEvidence(call.evidence), call.id);
+    batch.affectedCallerRepoIds.add(call.repoId);
+    matched = true;
+  }
+  if (matched || packageIdentityChanged(
+    target.packageName,
+    newPackageName
+  )) batch.affectedWorkspaceIds.add(target.workspaceId);
+}
+function createPackageInvalidationBatch(publishingRepoIds) {
+  return {
+    publishingRepoIds: new Set(publishingRepoIds),
+    affectedCallerRepoIds: /* @__PURE__ */ new Set(),
+    affectedWorkspaceIds: /* @__PURE__ */ new Set()
+  };
+}
+function finalizePackageTargetInvalidations(db, batch) {
+  const increment = db.prepare(`UPDATE repositories
+    SET fact_generation=fact_generation+1 WHERE id=?`);
+  for (const repoId of batch.affectedCallerRepoIds)
+    if (!batch.publishingRepoIds.has(repoId)) increment.run(repoId);
+  const stale = db.prepare(`UPDATE repositories
+    SET graph_stale_reason='package_target_facts_changed',
+      graph_stale_at=datetime('now') WHERE workspace_id=?`);
+  for (const workspaceId of batch.affectedWorkspaceIds)
+    stale.run(workspaceId);
+}
+
 // src/indexer/repository-indexer.ts
 async function prepareRepositoryIndex(repo, force, instrumentation) {
   const sourceFiles = await findSourceFiles(repo.absolute_path);
@@ -739,24 +2482,51 @@ async function prepareRepositoryIndex(repo, force, instrumentation) {
     packageSnapshot.rawText
   );
   if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
-  const parsed = await parseAllSourceFacts(repo.absolute_path, sources);
+  const parsedFacts = await parseAllSourceFacts(repo.absolute_path, sources);
+  const packageSurface = analyzeRepositoryPackageSurface(
+    packageFacts,
+    packageSnapshot.manifest,
+    sources
+  );
+  const parsed = {
+    ...parsedFacts,
+    symbols: mergePackageSymbolEvidence(parsedFacts.symbols, packageSurface)
+  };
   return {
     repo,
     packageFacts,
     fingerprint,
     kind: await classifyRepository(repo.absolute_path, packageFacts),
     parsed,
+    packagePublicSurface: packageSurface.surface,
     fileCount: sourceFiles.length,
     diagnosticCount: parsed.handlers.filter((handler) => handler.hasHandlerDecorator && (handler.methods.length === 0 || handler.methods.some((method) => !handlerMethodIsExecutable(method)))).length,
     skipped: false
   };
 }
-function publishPreparedRepositoryIndex(db, prepared) {
+function publishPreparedRepositoryIndex(db, prepared, invalidations) {
   if (prepared.skipped) return;
-  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind) throw new Error("Prepared repository index is missing publication facts");
+  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind || !prepared.packagePublicSurface)
+    throw new Error("Prepared repository index is missing publication facts");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const repoId = prepared.repo.id;
-  db.prepare("UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?").run(prepared.packageFacts.packageName, prepared.packageFacts.packageVersion, JSON.stringify(prepared.packageFacts.dependencies), prepared.kind, "indexing", repoId);
+  invalidatePackageTargetFacts(
+    db,
+    repoId,
+    prepared.packageFacts.packageName,
+    invalidations
+  );
+  db.prepare(`UPDATE repositories SET package_name=?, package_version=?,
+    dependencies_json=?,package_public_surface_json=?,kind=?,index_status=?
+    WHERE id=?`).run(
+    prepared.packageFacts.packageName,
+    prepared.packageFacts.packageVersion,
+    JSON.stringify(prepared.packageFacts.dependencies),
+    JSON.stringify(prepared.packagePublicSurface),
+    prepared.kind,
+    "indexing",
+    repoId
+  );
   clearRepoFacts(db, repoId);
   insertRequires(db, repoId, prepared.packageFacts.cdsRequires);
   const fileStmt = db.prepare("INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at");
@@ -783,13 +2553,36 @@ async function parseAllSourceFacts(root, sources) {
     facts.fileRecords.push({ relativePath: normalizePath(file), extension: path5.extname(file), sha256: sha256Text(snapshot.text), sizeBytes: snapshot.sizeBytes });
     if (file.endsWith(".cds")) facts.services.push(...await parseCdsFile(root, file, sources));
     if (/\.[jt]s$/.test(file)) {
+      const source = snapshot.sourceFile();
+      const classified = classifyOutboundCallsInSource(source, file);
       facts.handlers.push(...await parseDecorators(root, file, sources));
       facts.registrations.push(...await parseHandlerRegistrations(root, file, sources));
-      facts.bindings.push(...await parseServiceBindings(root, file, sources));
-      const symbolFacts = await parseExecutableSymbols(root, file, sources);
-      facts.symbols.push(...symbolFacts.symbols);
-      facts.symbolCalls.push(...symbolFacts.calls);
-      facts.calls.push(...await parseOutboundCalls(root, file, sources));
+      const bindings = await parseServiceBindings(root, file, sources);
+      const symbolFacts = await parseExecutableSymbols(
+        root,
+        file,
+        sources,
+        classified
+      );
+      const outboundCalls = await parseOutboundCalls(
+        root,
+        file,
+        sources,
+        classified,
+        bindings
+      );
+      const reconciled = reconcileSourceFacts(
+        source,
+        classified,
+        bindings,
+        outboundCalls,
+        symbolFacts.symbols,
+        symbolFacts.calls
+      );
+      facts.bindings.push(...reconciled.bindings);
+      facts.symbols.push(...reconciled.symbols);
+      facts.symbolCalls.push(...reconciled.symbolCalls);
+      facts.calls.push(...reconciled.outboundCalls);
     }
   }
   return facts;
@@ -906,15 +2699,15 @@ function relativeBase(db, extension, symbol) {
   return db.prepare(`SELECT s.id,s.repo_id repoId FROM cds_services s WHERE s.repo_id=? AND s.is_extend=0 AND (s.qualified_name=? OR s.service_name=?) AND (s.source_file=? OR s.source_file=?) ORDER BY s.id`).all(extension.repoId, symbol, symbol, modulePath, `${modulePath}.cds`);
 }
 function packageBase(db, workspaceId, specifier, symbol) {
-  const packageName = packageNameFromSpecifier(specifier);
-  const moduleSuffix = specifier.slice(packageName.length).replace(/^\//, "");
-  return db.prepare(`SELECT s.id,s.repo_id repoId FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=0 AND r.package_name=? AND (s.qualified_name=? OR s.service_name=?) AND (?='' OR s.source_file=? OR s.source_file=?) ORDER BY s.id`).all(workspaceId, packageName, symbol, symbol, moduleSuffix, moduleSuffix, `${moduleSuffix}.cds`);
+  const packageName2 = packageNameFromSpecifier(specifier);
+  const moduleSuffix = specifier.slice(packageName2.length).replace(/^\//, "");
+  return db.prepare(`SELECT s.id,s.repo_id repoId FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=0 AND r.package_name=? AND (s.qualified_name=? OR s.service_name=?) AND (?='' OR s.source_file=? OR s.source_file=?) ORDER BY s.id`).all(workspaceId, packageName2, symbol, symbol, moduleSuffix, moduleSuffix, `${moduleSuffix}.cds`);
 }
 function sameRepoBase(db, extension, symbol) {
   return db.prepare("SELECT id,repo_id repoId FROM cds_services WHERE repo_id=? AND is_extend=0 AND (qualified_name=? OR service_name=?) ORDER BY id").all(extension.repoId, symbol, symbol);
 }
-function normalizeModulePath(sourceFile, specifier) {
-  const base = sourceFile.split("/").slice(0, -1).join("/");
+function normalizeModulePath(sourceFile2, specifier) {
+  const base = sourceFile2.split("/").slice(0, -1).join("/");
   const parts = `${base}/${specifier}`.split("/");
   const out = [];
   for (const part of parts) {
@@ -985,42 +2778,91 @@ function claimIndexRun(db, workspaceId, repoCount) {
   }
 }
 async function indexWorkspace(db, workspaceId, options) {
-  const repos = options.repo ? reposByName(db, options.repo, workspaceId) : listRepositories(db, workspaceId);
-  if (options.repo && repos.length === 0)
-    throw new Error(`selector_repo_not_found: no indexed repository matched ${options.repo}.`);
-  if (options.repo && repos.length > 1)
-    throw new Error(`selector_repo_ambiguous: repository selector ${options.repo} matched ${repos.length} repositories; use a unique repository name.`);
+  const repos = selectedRepositories(db, workspaceId, options.repo);
   const runId = claimIndexRun(db, workspaceId, repos.length);
-  let fileCount = 0;
-  let diagnosticCount = 0;
-  let skippedCount = 0;
-  const preparedRows = [];
-  let activeRepoId;
+  const state = {
+    fileCount: 0,
+    diagnosticCount: 0,
+    skippedCount: 0,
+    rows: []
+  };
   try {
-    for (const repo of repos) {
-      activeRepoId = repo.id;
-      const result = await prepareRepositoryIndex(repo, options.force);
-      preparedRows.push(result);
-      fileCount += result.fileCount;
-      diagnosticCount += result.diagnosticCount;
-      skippedCount += result.skipped ? 1 : 0;
-    }
-    db.transaction(() => {
-      for (const row of preparedRows) {
-        activeRepoId = row.repo.id;
-        publishPreparedRepositoryIndex(db, row);
-      }
-      if (options.injectDerivedMaterializationFailure) throw new Error("Injected derived materialization failure");
-      materializeCdsExtensionOperations(db, workspaceId);
-      db.prepare("UPDATE index_runs SET finished_at=?, status='success', file_count=?, diagnostic_count=? WHERE id=?").run((/* @__PURE__ */ new Date()).toISOString(), fileCount, diagnosticCount, runId);
-    });
-    return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
+    await prepareRepositories(repos, options.force, state);
+    publishPreparedRows(db, workspaceId, options, runId, state);
+    return indexSummary(repos.length, state);
   } catch (error) {
-    db.prepare("UPDATE index_runs SET finished_at=?, status='failed', file_count=?, diagnostic_count=?, error_message=? WHERE id=?").run((/* @__PURE__ */ new Date()).toISOString(), fileCount, diagnosticCount + 1, errorMessage(error), runId);
-    if (activeRepoId && preparedRows.length < repos.length) recordIndexFailure(db, activeRepoId, error);
+    finishFailedRun(db, runId, state, error);
+    if (state.activeRepoId && state.rows.length < repos.length)
+      recordIndexFailure(db, state.activeRepoId, error);
     throw error;
   }
 }
+function selectedRepositories(db, workspaceId, repoName) {
+  const repos = repoName ? reposByName(db, repoName, workspaceId) : listRepositories(db, workspaceId);
+  if (repoName && repos.length === 0)
+    throw new Error(
+      `selector_repo_not_found: no indexed repository matched ${repoName}.`
+    );
+  if (repoName && repos.length > 1)
+    throw new Error(
+      `selector_repo_ambiguous: repository selector ${repoName} matched ${repos.length} repositories; use a unique repository name.`
+    );
+  return repos;
+}
+async function prepareRepositories(repos, force, state) {
+  for (const repo of repos) {
+    state.activeRepoId = repo.id;
+    const result = await prepareRepositoryIndex(repo, force);
+    state.rows.push(result);
+    state.fileCount += result.fileCount;
+    state.diagnosticCount += result.diagnosticCount;
+    state.skippedCount += result.skipped ? 1 : 0;
+  }
+}
+function publishPreparedRows(db, workspaceId, options, runId, state) {
+  db.transaction(() => {
+    const invalidations = createPackageInvalidationBatch(
+      state.rows.filter((row) => !row.skipped).map((row) => row.repo.id)
+    );
+    for (const row of state.rows) {
+      state.activeRepoId = row.repo.id;
+      publishPreparedRepositoryIndex(db, row, invalidations);
+    }
+    if (options.injectDerivedMaterializationFailure)
+      throw new Error("Injected derived materialization failure");
+    materializeCdsExtensionOperations(db, workspaceId);
+    finalizePackageTargetInvalidations(db, invalidations);
+    finishSuccessfulRun(db, runId, state);
+  });
+}
+function finishSuccessfulRun(db, runId, state) {
+  db.prepare(`UPDATE index_runs SET finished_at=?,status='success',
+    file_count=?,diagnostic_count=? WHERE id=?`).run(
+    (/* @__PURE__ */ new Date()).toISOString(),
+    state.fileCount,
+    state.diagnosticCount,
+    runId
+  );
+}
+function finishFailedRun(db, runId, state, error) {
+  db.prepare(`UPDATE index_runs SET finished_at=?,status='failed',
+    file_count=?,diagnostic_count=?,error_message=? WHERE id=?`).run(
+    (/* @__PURE__ */ new Date()).toISOString(),
+    state.fileCount,
+    state.diagnosticCount + 1,
+    errorMessage(error),
+    runId
+  );
+}
+function indexSummary(repoCount, state) {
+  return {
+    repoCount,
+    indexedCount: repoCount - state.skippedCount,
+    skippedCount: state.skippedCount,
+    fileCount: state.fileCount,
+    diagnosticCount: state.diagnosticCount
+  };
+}
 
 // src/cli/001-doctor-projection.ts
 var boundedDoctorArrayKeys = /* @__PURE__ */ new Set([
@@ -1191,15 +3033,88 @@ function analyzerVersionDiagnostics(db, strict, workspaceId) {
   return [{ severity: "warning", code: "reindex_required_after_analyzer_upgrade", message: "Repository facts were produced by an older or unknown analyzer; run service-flow index --force before relink to apply current parser semantics.", scope: "workspace", affectedRepositoryCount: rows.length, currentAnalyzerVersion: ANALYZER_VERSION, repositories: rows, remediation: "service-flow index --force && service-flow link" }];
 }
 
+// src/cli/003-doctor-package-resolution.ts
+function pendingPredicate(alias) {
+  return `${alias}.status='unresolved'
+    AND ${alias}.callee_symbol_id IS NULL
+    AND ${alias}.unresolved_reason='package_resolution_pending'
+    AND json_extract(${alias}.evidence_json,'$.relation')='package_import'
+    AND json_extract(${alias}.evidence_json,
+      '$.importBinding.moduleKind')='package'
+    AND json_extract(${alias}.evidence_json,
+      '$.candidateStrategy')='package_import_pending'
+    AND json_extract(${alias}.evidence_json,'$.candidateCount')=0
+    AND json_extract(${alias}.evidence_json,'$.eligibleCandidateCount')=0
+    AND json_extract(${alias}.evidence_json,'$.selectedCandidateCount')=0
+    AND json_extract(${alias}.evidence_json,'$.candidateSetComplete')=0`;
+}
+function count(db, sql) {
+  return Number(db.prepare(sql).get()?.count ?? 0);
+}
+function packagePendingDiagnostics(db) {
+  const pending = count(db, `SELECT COUNT(*) count FROM symbol_calls sc
+    WHERE ${pendingPredicate("sc")}`);
+  if (pending === 0) return [];
+  const stale = count(db, `SELECT COUNT(*) count FROM repositories
+    WHERE graph_stale_reason IS NOT NULL`);
+  return [{
+    severity: "warning",
+    code: "package_import_resolution_pending",
+    message: "Package-import facts await workspace linking; terminal package-resolution quality is deferred.",
+    packageResolutionState: "pre_link_pending",
+    pendingPackageImportCount: pending,
+    graphState: "stale",
+    staleRepositoryCount: stale,
+    requiredAction: "relink",
+    remediation: "service-flow link --workspace /workspace --force"
+  }];
+}
+function symbolCallQuality(db) {
+  const terminal = `NOT (${pendingPredicate("sc")})`;
+  const row = db.prepare(`SELECT COUNT(*) total,
+    SUM(CASE WHEN sc.status='resolved' THEN 1 ELSE 0 END) resolved,
+    SUM(CASE WHEN sc.status='unresolved' THEN 1 ELSE 0 END) unresolved
+    FROM symbol_calls sc WHERE ${terminal}`).get();
+  const top = db.prepare(`SELECT sc.callee_expression calleeExpression,
+    COUNT(*) count FROM symbol_calls sc
+    WHERE sc.status='unresolved' AND ${terminal}
+    GROUP BY sc.callee_expression
+    ORDER BY count DESC,sc.callee_expression COLLATE BINARY LIMIT 5`).all();
+  const total = Number(row?.total ?? 0);
+  const unresolved = Number(row?.unresolved ?? 0);
+  const ratio = total === 0 ? 0 : Number((unresolved / total).toFixed(4));
+  return {
+    severity: ratio > 0.05 ? "warning" : "info",
+    code: "strict_symbol_call_quality",
+    message: "Terminal symbol-call quality aggregate",
+    total,
+    resolved: Number(row?.resolved ?? 0),
+    unresolved,
+    unresolvedRatio: ratio,
+    unresolvedRatioThreshold: 0.05,
+    topUnresolvedCallees: top
+  };
+}
+
 // src/cli/doctor.ts
 function doctorDiagnostics(db, strict, options = {}) {
   const lifecycle = factLifecycleDiagnostic(db, options.workspaceId);
-  if (lifecycle?.code === "schema_upgrade_required" || lifecycle?.code === "unsupported_future_schema")
-    return boundDoctorDiagnostics([lifecycle]);
+  if (lifecycle) return boundDoctorDiagnostics([lifecycle]);
+  const globalLifecycle = options.workspaceId === void 0 ? void 0 : factLifecycleDiagnostic(db);
+  if (globalLifecycle) return boundDoctorDiagnostics([
+    ...schemaDriftDiagnostics(db, strict, options.workspaceId),
+    ...analyzerVersionDiagnostics(db, strict, options.workspaceId),
+    {
+      severity: "warning",
+      code: "workspace_detail_checks_deferred",
+      message: "Selected-workspace lifecycle is valid, but JSON-dependent global detail checks were deferred because another workspace requires reindexing.",
+      remediation: "Run doctor for the affected workspace after force index and link."
+    }
+  ]);
   const diagnostics = db.prepare("SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id").all();
   return boundDoctorDiagnostics([
-    ...lifecycle ? [lifecycle] : [],
     ...diagnostics,
+    ...packagePendingDiagnostics(db),
     ...healthDiagnostics(db, strict),
     ...remoteTargetWithoutImplementationDiagnostics(db, strict, Boolean(options.detail)),
     ...localServiceDiagnostics(db, strict),
@@ -1338,14 +3253,6 @@ function jsonEvidenceQuality(db) {
     { severity: Number(graph.nonObject ?? 0) > 0 || Number(graph.withOutboundEvidence ?? 0) < Number(graph.total ?? 0) ? "warning" : "info", code: "strict_graph_evidence_quality", message: "Call-derived graph evidence and parser-evidence propagation aggregate", total: Number(graph.total ?? 0), nonObject: Number(graph.nonObject ?? 0), withOutboundEvidence: Number(graph.withOutboundEvidence ?? 0), examples: graphExamples }
   ];
 }
-function symbolCallQuality(db) {
-  const row = db.prepare("SELECT COUNT(*) total, SUM(CASE WHEN status='resolved' THEN 1 ELSE 0 END) resolved, SUM(CASE WHEN status='unresolved' THEN 1 ELSE 0 END) unresolved FROM symbol_calls").get();
-  const top = db.prepare("SELECT callee_expression calleeExpression,COUNT(*) count FROM symbol_calls WHERE status='unresolved' GROUP BY callee_expression ORDER BY count DESC,callee_expression LIMIT 5").all();
-  const total = Number(row.total ?? 0);
-  const unresolved = Number(row.unresolved ?? 0);
-  const ratio = total === 0 ? 0 : Number((unresolved / total).toFixed(4));
-  return { severity: ratio > 0.05 ? "warning" : "info", code: "strict_symbol_call_quality", message: "Symbol-call quality aggregate", total, resolved: Number(row.resolved ?? 0), unresolved, unresolvedRatio: ratio, unresolvedRatioThreshold: 0.05, topUnresolvedCallees: top };
-}
 function dbQueryQuality(db) {
   const row = db.prepare("SELECT COUNT(*) total, SUM(CASE WHEN query_entity IS NOT NULL THEN 1 ELSE 0 END) known, SUM(CASE WHEN query_entity IS NULL THEN 1 ELSE 0 END) unknown FROM outbound_calls WHERE call_type='local_db_query'").get();
   const total = Number(row.total ?? 0);
@@ -1561,8 +3468,12 @@ function serviceBindingQuality(db, detail) {
 function bindingCategory(row) {
   const evidence = parseObject(row.evidenceJson);
   const resolution = parseObject(evidence.serviceBindingResolution);
+  const reference = parseObject(evidence.serviceBindingReference);
   if (resolution.status === "rejected_future_binding") return "direct_binding_missing";
-  if (resolution.status === "ambiguous") return "ambiguous_binding_candidates";
+  if (reference.reason === "binding_declared_after_call")
+    return "direct_binding_missing";
+  if (resolution.status === "ambiguous" || reference.status === "ambiguous" || reference.reason === "unsupported_reaching_assignment")
+    return "ambiguous_binding_candidates";
   const receiver = evidence.receiver;
   const symbolEvidence = parseObject(row.symbolEvidenceJson);
   if (symbolHasReceiverParameter(symbolEvidence, receiver))
@@ -1588,7 +3499,8 @@ function bindingExample(row) {
     sourceLine: row.sourceLine,
     receiver: evidence.receiver,
     unresolvedReason: row.unresolvedReason,
-    bindingResolution: evidence.serviceBindingResolution
+    bindingResolution: evidence.serviceBindingResolution,
+    bindingReference: evidence.serviceBindingReference
   };
 }
 function bindingCategoryAction(category) {
@@ -1841,8 +3753,8 @@ function hintLines(evidence) {
 }
 function dynamicHintLines(evidence) {
   const exploration = isRecord(evidence.dynamicTargetExploration) ? evidence.dynamicTargetExploration : evidence;
-  const count = numberValue(exploration.candidateCount);
-  if (count === 0) return [];
+  const count2 = numberValue(exploration.candidateCount);
+  if (count2 === 0) return [];
   const shown = numberValue(exploration.shownCandidateCount);
   const omitted = numberValue(exploration.omittedCandidateCount);
   const rejected = numberValue(exploration.rejectedCandidateCount);
@@ -1850,7 +3762,7 @@ function dynamicHintLines(evidence) {
     `viable candidates: ${shown} shown, ${omitted} omitted; rejected: ${rejected}`
   ];
   lines.push(...varSetHints(exploration.suggestedVarSets));
-  if (omitted > 0 || rejected > 0 || shown < count)
+  if (omitted > 0 || rejected > 0 || shown < count2)
     lines.push("use --dynamic-mode candidates --max-dynamic-candidates 20 to explore candidate branches");
   return lines;
 }
@@ -1920,9 +3832,9 @@ function diagnosticLocation(diagnostic) {
 }
 function compactMessage(diagnostic) {
   const message = String(diagnostic.message ?? "");
-  const count = typeof diagnostic.count === "number" ? ` count=${diagnostic.count}` : "";
+  const count2 = typeof diagnostic.count === "number" ? ` count=${diagnostic.count}` : "";
   const total = typeof diagnostic.total === "number" ? ` total=${diagnostic.total}` : "";
-  return `${message}${count}${total}`.trim();
+  return `${message}${count2}${total}`.trim();
 }
 function suggestedHintLines(diagnostic) {
   const direct = cliHints(diagnostic.suggestedHints);