@saptools/service-flow 0.1.70 → 0.1.72

package/dist/cli.js

@@ -8,14 +8,20 @@ import {
   bindingSite,
   classifyODataPathIntent,
   classifyOutboundCallsInSource,
+  collectEnvironmentDeclarations,
+  collectStringConstantLookups,
   collectSymbolImportBindings,
   compactTrace,
   containsSupportedOutboundCall,
   createBindingLexicalIndex,
+  createEventEnvironmentReferenceResolver,
+  createImportedEventNameResolver,
   derivedMemberImportReference,
   discoverRepositories,
+  emptyEnvironmentDeclarations,
   executableSymbolCandidates,
   factLifecycleDiagnostic,
+  generatedConstantFacts,
   identifierMatchesDeclaration,
   implementationHintSuggestions,
   insertCalls,
@@ -42,13 +48,15 @@ import {
   projectBoundedInOrder,
   recordPreparedSnapshotFailure,
   redactValue,
+  resolveBinding,
   selectCallOwner,
   selectVisibleBinding,
   selectorRepoAmbiguousDiagnostic,
+  sha256Text,
   stableLocalValueReference,
   symbolImportReference,
   trace
-} from "./chunk-GSLFY6J2.js";
+} from "./chunk-Z6D433R5.js";
 
 // src/cli.ts
 import { Command, Option } from "commander";
@@ -250,8 +258,8 @@ 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(?,?,?,?,?,?,?,?,?,?)
+      package_public_surface_json,environment_declarations_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,
@@ -266,6 +274,7 @@ function upsertRepository(db, workspaceId, r) {
     r.packageVersion,
     JSON.stringify(r.dependencies ?? {}),
     initialPackagePublicSurface(r.packageName),
+    JSON.stringify(emptyEnvironmentDeclarations()),
     r.kind ?? "unknown",
     r.isGitRepo ? 1 : 0
   );
@@ -292,6 +301,7 @@ function clearRepoFacts(db, repoId) {
     "symbol_calls",
     "handler_registrations",
     "service_bindings",
+    "generated_constants",
     "symbols",
     "diagnostics",
     "files"
@@ -299,6 +309,32 @@ function clearRepoFacts(db, repoId) {
     db.prepare(`DELETE FROM ${t} WHERE repo_id=?`).run(repoId);
   db.prepare("DELETE FROM search_index WHERE repo=?").run(String(repoId));
 }
+function insertGeneratedConstants(db, repoId, rows) {
+  const stmt = db.prepare(`INSERT INTO generated_constants(
+    repo_id,source_file,source_line,name,container_name,member_name,value,
+    constant_kind,exported,stable,resolution_status,unresolved_reason,
+    declaration_start_offset,declaration_end_offset,
+    value_start_offset,value_end_offset
+  ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`);
+  for (const row of rows) stmt.run(
+    repoId,
+    row.sourceFile,
+    row.sourceLine,
+    row.name,
+    row.containerName ?? null,
+    row.memberName ?? null,
+    row.value ?? null,
+    row.constantKind,
+    row.exported ? 1 : 0,
+    row.stable ? 1 : 0,
+    row.resolutionStatus,
+    row.unresolvedReason ?? null,
+    row.declarationStartOffset,
+    row.declarationEndOffset,
+    row.valueStartOffset,
+    row.valueEndOffset
+  );
+}
 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(?,?,?,?,?,?,?,?)"
@@ -612,10 +648,10 @@ import path5 from "path";
 // src/parsers/symbol-parser.ts
 import fs4 from "fs/promises";
 import path4 from "path";
-import ts8 from "typescript";
+import ts9 from "typescript";
 
 // src/parsers/event-subscription-facts.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/parsers/local-symbol-reference.ts
 import ts from "typescript";
@@ -752,6 +788,89 @@ function localSymbolTarget(expression, source, symbols) {
   return declaration ? exactPropertyTarget(expression, declaration, symbols, source) : void 0;
 }
 
+// src/parsers/event-loop-registration.ts
+import ts2 from "typescript";
+var loopValueCap = 32;
+var loopExpressionLimit = 256;
+function unwrap(expression) {
+  if (ts2.isParenthesizedExpression(expression) || ts2.isAsExpression(expression) || ts2.isSatisfiesExpression(expression) || ts2.isTypeAssertionExpression(expression))
+    return unwrap(expression.expression);
+  return expression;
+}
+function stringArray(expression) {
+  const value = unwrap(expression);
+  if (!ts2.isArrayLiteralExpression(value)) return void 0;
+  const strings = value.elements.flatMap((element) => {
+    const item = ts2.isSpreadElement(element) ? void 0 : unwrap(element);
+    return item && ts2.isStringLiteralLike(item) ? [item.text] : [];
+  });
+  return strings.length === value.elements.length ? strings : void 0;
+}
+function identifierArray(identifier) {
+  const binding = resolveBinding(identifier, identifier);
+  return binding.immutable && binding.initializer ? stringArray(binding.initializer) : void 0;
+}
+function orderedValues(values) {
+  return [...values].sort((left, right) => left.declarationStartOffset - right.declarationStartOffset).map((item) => item.value);
+}
+function objectValues(expression, source) {
+  if (!ts2.isPropertyAccessExpression(expression.expression))
+    return void 0;
+  const root = expression.expression.expression;
+  if (!ts2.isIdentifier(root) || root.text !== "Object" || lexicalIdentifierDeclaration(root) || expression.expression.name.text !== "values" || expression.arguments.length !== 1) return void 0;
+  const argument = expression.arguments[0];
+  if (!argument || !ts2.isIdentifier(argument)) return void 0;
+  const lookups = collectStringConstantLookups(source);
+  const prefix = `${argument.text}.`;
+  const refused = [...lookups.refusedMembers.keys()].some((key) => key.startsWith(prefix));
+  const values = [
+    ...lookups.enumMembers.values(),
+    ...lookups.objectProperties.values()
+  ].filter((item) => item.key.startsWith(prefix));
+  return !refused && values.length > 0 ? orderedValues(values) : void 0;
+}
+function staticCollectionValues(expression, source) {
+  const value = unwrap(expression);
+  if (ts2.isArrayLiteralExpression(value)) return stringArray(value);
+  if (ts2.isIdentifier(value)) return identifierArray(value);
+  return ts2.isCallExpression(value) ? objectValues(value, source) : void 0;
+}
+function enclosingForEach(node) {
+  let current = node.parent;
+  while (current && !ts2.isSourceFile(current)) {
+    if ((ts2.isArrowFunction(current) || ts2.isFunctionExpression(current)) && ts2.isCallExpression(current.parent) && current.parent.arguments.includes(current) && ts2.isPropertyAccessExpression(current.parent.expression) && current.parent.expression.name.text === "forEach")
+      return current.parent;
+    if (ts2.isFunctionLike(current)) return void 0;
+    current = current.parent;
+  }
+  return void 0;
+}
+function boundedExpression(expression, source) {
+  return expression.getText(source).slice(0, loopExpressionLimit);
+}
+function eventLoopRegistrationEvidence(node, source) {
+  const loop = enclosingForEach(node);
+  if (!loop || !ts2.isPropertyAccessExpression(loop.expression)) return {};
+  const collection = loop.expression.expression;
+  const values = staticCollectionValues(collection, source);
+  if (!values) return {
+    subscriptionRegisteredInLoop: true,
+    subscriptionLoopRegistrationStatus: "unresolved",
+    subscriptionLoopUnresolvedReason: "subscription_loop_collection_not_statically_enumerable",
+    subscriptionLoopCollectionExpression: boundedExpression(collection, source)
+  };
+  const shown = values.slice(0, loopValueCap);
+  return {
+    subscriptionRegisteredInLoop: true,
+    subscriptionLoopRegistrationStatus: "enumerated",
+    subscriptionLoopCollectionExpression: boundedExpression(collection, source),
+    subscriptionLoopRegistrationCount: values.length,
+    subscriptionLoopValues: shown,
+    shownSubscriptionLoopValueCount: shown.length,
+    omittedSubscriptionLoopValueCount: Math.max(0, values.length - shown.length)
+  };
+}
+
 // src/parsers/event-subscription-facts.ts
 function lineOf(source, node) {
   return source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
@@ -766,7 +885,7 @@ function importRelation(binding) {
 function directTarget(expression, source, imports, symbols) {
   const imported = symbolImportReference(expression, imports);
   if (imported) return importedTarget(expression, source, imported);
-  if (ts2.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     const exact = localSymbolTarget(expression, source, symbols);
     return {
       calleeExpression: expression.text,
@@ -789,7 +908,7 @@ function importedTarget(expression, source, binding) {
   };
 }
 function propertyTarget(expression, source, symbols) {
-  if (!ts2.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts2.isIdentifier(expression.expression)) return void 0;
+  if (!ts3.isPropertyAccessExpression(expression) || expression.questionDotToken || !ts3.isIdentifier(expression.expression)) return void 0;
   const exact = localSymbolTarget(expression, source, symbols);
   return {
     calleeExpression: expression.getText(source),
@@ -809,7 +928,7 @@ function classifyHandlerReference(expression, source, imports = collectSymbolImp
       "handler_argument_missing",
       "missing"
     );
-  if (ts2.isArrowFunction(expression) || ts2.isFunctionExpression(expression))
+  if (ts3.isArrowFunction(expression) || ts3.isFunctionExpression(expression))
     return unsupportedClassification(
       "unsupported_inline",
       "inline_handler_body_not_indexed",
@@ -818,7 +937,7 @@ function classifyHandlerReference(expression, source, imports = collectSymbolImp
   const direct = directTarget(expression, source, imports, symbols);
   if (direct)
     return { status: "role_required", referenceShape: direct.referenceShape, target: direct };
-  if (!ts2.isCallExpression(expression))
+  if (!ts3.isCallExpression(expression))
     return unsupportedClassification(
       "unsupported_reference_shape",
       "handler_reference_shape_unsupported",
@@ -906,6 +1025,7 @@ function enrichSubscription(source, classified, symbols) {
   );
   const evidence = {
     ...classified.fact.evidence ?? {},
+    ...eventLoopRegistrationEvidence(classified.node, source),
     handlerReferenceStatus: classification.status,
     ...classification.reason ? { handlerReferenceReason: classification.reason } : {},
     handlerReferenceShape: classification.referenceShape
@@ -939,7 +1059,7 @@ function reconcileEventSubscriptions(source, classifications, symbols, calls) {
 import "typescript";
 
 // src/parsers/binding-identity.ts
-import ts3 from "typescript";
+import ts4 from "typescript";
 var scopeChainCap = 16;
 function matchFactsToSites(index, facts) {
   return facts.map((fact) => {
@@ -1059,9 +1179,9 @@ function assertUniqueSites(bindings) {
 function callNodeMap(source) {
   const calls = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (ts3.isCallExpression(node))
+    if (ts4.isCallExpression(node))
       calls.set(`${node.getStart(source)}:${node.getEnd()}`, node);
-    ts3.forEachChild(node, visit);
+    ts4.forEachChild(node, visit);
   };
   visit(source);
   return calls;
@@ -1254,7 +1374,7 @@ function reconcileSourceFacts(source, classifications, bindings, outboundCalls,
 }
 
 // src/parsers/symbol-call-facts.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 var commonTerminalMembers = /* @__PURE__ */ new Set([
   "push",
   "includes",
@@ -1322,8 +1442,8 @@ var cdsFrameworkPrefixes = [
   "cds.parse."
 ];
 function symbolCallName(expr) {
-  if (ts5.isIdentifier(expr)) return { expression: expr.text, local: expr.text };
-  if (!ts5.isPropertyAccessExpression(expr))
+  if (ts6.isIdentifier(expr)) return { expression: expr.text, local: expr.text };
+  if (!ts6.isPropertyAccessExpression(expr))
     return { expression: expr.getText() };
   const left = expr.expression.getText();
   return {
@@ -1355,25 +1475,25 @@ function ignoredFrameworkCall(callee) {
 }
 function argumentEvidence(args) {
   return args.map((arg) => {
-    if (ts5.isIdentifier(arg)) return { kind: "identifier", name: arg.text };
-    if (ts5.isArrayLiteralExpression(arg)) return {
+    if (ts6.isIdentifier(arg)) return { kind: "identifier", name: arg.text };
+    if (ts6.isArrayLiteralExpression(arg)) return {
       kind: "array_literal",
-      elements: arg.elements.flatMap((item, index) => ts5.isIdentifier(item) ? [{ index, kind: "identifier", name: item.text }] : [])
+      elements: arg.elements.flatMap((item, index) => ts6.isIdentifier(item) ? [{ index, kind: "identifier", name: item.text }] : [])
     };
-    if (ts5.isObjectLiteralExpression(arg))
+    if (ts6.isObjectLiteralExpression(arg))
       return objectArgumentEvidence(arg);
     return { kind: "unsupported", expression: arg.getText() };
   });
 }
 function objectArgumentEvidence(argument) {
   const properties = argument.properties.flatMap((property) => {
-    if (ts5.isShorthandPropertyAssignment(property))
+    if (ts6.isShorthandPropertyAssignment(property))
       return [{
         kind: "shorthand",
         property: property.name.text,
         argument: property.name.text
       }];
-    if (!ts5.isPropertyAssignment(property) || !ts5.isIdentifier(property.initializer)) return [];
+    if (!ts6.isPropertyAssignment(property) || !ts6.isIdentifier(property.initializer)) return [];
     const name = propertyName(property.name);
     return name ? [{
       kind: "property_assignment",
@@ -1384,7 +1504,7 @@ function objectArgumentEvidence(argument) {
   return { kind: "object_literal", properties };
 }
 function propertyName(name) {
-  return ts5.isIdentifier(name) || ts5.isStringLiteralLike(name) || ts5.isNumericLiteral(name) ? name.text : void 0;
+  return ts6.isIdentifier(name) || ts6.isStringLiteralLike(name) || ts6.isNumericLiteral(name) ? name.text : void 0;
 }
 function exactCaller(collection, node) {
   const selected = selectCallOwner(
@@ -1445,9 +1565,9 @@ function callFact(collection, node) {
 }
 function expressionRoot(expression) {
   let current = expression;
-  while (ts5.isPropertyAccessExpression(current))
+  while (ts6.isPropertyAccessExpression(current))
     current = current.expression;
-  return ts5.isIdentifier(current) ? current : void 0;
+  return ts6.isIdentifier(current) ? current : void 0;
 }
 function exactDeclaredContext(identifier, candidates) {
   const matches = candidates.filter((candidate) => identifierMatchesDeclaration(
@@ -1478,8 +1598,8 @@ function callInstance(collection, node, callee) {
 }
 function enclosingClass(node) {
   let current = node.parent;
-  while (current && !ts5.isSourceFile(current)) {
-    if (ts5.isClassLike(current)) return current;
+  while (current && !ts6.isSourceFile(current)) {
+    if (ts6.isClassLike(current)) return current;
     current = current.parent;
   }
   return void 0;
@@ -1619,26 +1739,26 @@ function parserCandidateStrategy(context) {
 function collectSymbolCallFacts(collection) {
   const calls = [];
   const visit = (node) => {
-    if (ts5.isCallExpression(node)) {
+    if (ts6.isCallExpression(node)) {
       const call = callFact(collection, node);
       if (call) calls.push(call);
     }
-    ts5.forEachChild(node, visit);
+    ts6.forEachChild(node, visit);
   };
   visit(collection.source);
   return calls;
 }
 
 // src/parsers/executable-body-eligibility.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 function hasModifier(node, kind) {
-  return ts6.canHaveModifiers(node) && Boolean(ts6.getModifiers(node)?.some((item) => item.kind === kind));
+  return ts7.canHaveModifiers(node) && Boolean(ts7.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))
+  if (hasModifier(node, ts7.SyntaxKind.AbstractKeyword))
     return { eligible: false, reason: "abstract_bodyless" };
-  if (hasModifier(node, ts6.SyntaxKind.DeclareKeyword))
+  if (hasModifier(node, ts7.SyntaxKind.DeclareKeyword))
     return { eligible: false, reason: "ambient_declaration" };
   return {
     eligible: false,
@@ -1647,7 +1767,7 @@ function executableBodyEligibility(node, source) {
 }
 
 // src/parsers/symbol-derived-contexts.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 var builtInConstructors = /* @__PURE__ */ new Set([
   "Set",
   "Map",
@@ -1688,23 +1808,23 @@ function appendNamed(values, name, value) {
   values.set(name, matches);
 }
 function assignmentOperator2(kind) {
-  return kind >= ts7.SyntaxKind.FirstAssignment && kind <= ts7.SyntaxKind.LastAssignment;
+  return kind >= ts8.SyntaxKind.FirstAssignment && kind <= ts8.SyntaxKind.LastAssignment;
 }
 function mutationUnary2(node) {
-  return node.operator === ts7.SyntaxKind.PlusPlusToken || node.operator === ts7.SyntaxKind.MinusMinusToken;
+  return node.operator === ts8.SyntaxKind.PlusPlusToken || node.operator === ts8.SyntaxKind.MinusMinusToken;
 }
 function receiverIdentifier(expression) {
   let current = expression;
-  while (ts7.isPropertyAccessExpression(current) || ts7.isElementAccessExpression(current))
+  while (ts8.isPropertyAccessExpression(current) || ts8.isElementAccessExpression(current))
     current = current.expression;
-  return ts7.isIdentifier(current) ? current : void 0;
+  return ts8.isIdentifier(current) ? current : void 0;
 }
 function nodeWritesMember(node, matches) {
-  if (ts7.isBinaryExpression(node))
+  if (ts8.isBinaryExpression(node))
     return assignmentOperator2(node.operatorToken.kind) && matches(node.left);
-  if (ts7.isPrefixUnaryExpression(node) || ts7.isPostfixUnaryExpression(node))
+  if (ts8.isPrefixUnaryExpression(node) || ts8.isPostfixUnaryExpression(node))
     return mutationUnary2(node) && matches(node.operand);
-  return ts7.isDeleteExpression(node) && matches(node.expression);
+  return ts8.isDeleteExpression(node) && matches(node.expression);
 }
 function memberWrite(source, declaration) {
   const start = declaration.getStart(source);
@@ -1717,16 +1837,16 @@ function memberWrite(source, declaration) {
   const visit = (node) => {
     if (written) return;
     written = nodeWritesMember(node, matches);
-    if (!written) ts7.forEachChild(node, visit);
+    if (!written) ts8.forEachChild(node, visit);
   };
   visit(source);
   return written;
 }
 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);
+  return ts8.isIdentifier(node.name) && ts8.isVariableDeclarationList(node.parent) && (node.parent.flags & ts8.NodeFlags.Const) !== 0 && !memberWrite(collection.source, node.name);
 }
 function collectProxy(collection, node) {
-  if (!ts7.isVariableDeclaration(node) || !stableVariable(collection, node) || !node.initializer || !ts7.isCallExpression(node.initializer) || !ts7.isPropertyAccessExpression(node.initializer.expression)) return;
+  if (!ts8.isVariableDeclaration(node) || !stableVariable(collection, node) || !node.initializer || !ts8.isCallExpression(node.initializer) || !ts8.isPropertyAccessExpression(node.initializer.expression)) return;
   const callee = symbolCallName(node.initializer.expression);
   const binding = symbolImportReference(
     node.initializer.expression,
@@ -1743,8 +1863,8 @@ function collectProxy(collection, node) {
   });
 }
 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;
+  const property = propertyName3 && ts8.isPropertyDeclaration(declaration.parent) ? declaration.parent : void 0;
+  return property && ts8.isClassLike(property.parent) ? property.parent : void 0;
 }
 function eligibleClassName(collection, className, imported) {
   if (builtInConstructors.has(className)) return false;
@@ -1775,43 +1895,43 @@ function rememberInstance(collection, declaration, classExpression, propertyName
   });
 }
 function collectVariableInstance(collection, node) {
-  if (!ts7.isVariableDeclaration(node) || !stableVariable(collection, node))
+  if (!ts8.isVariableDeclaration(node) || !stableVariable(collection, node))
     return;
   const initializer = node.initializer;
-  if (initializer && ts7.isNewExpression(initializer) && ts7.isIdentifier(initializer.expression))
+  if (initializer && ts8.isNewExpression(initializer) && ts8.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;
+  return ts8.isIdentifier(name) || ts8.isStringLiteralLike(name) || ts8.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);
+  if (ts8.isPropertyAccessExpression(expression))
+    return expression.expression.kind === ts8.SyntaxKind.ThisKeyword && expression.name.text === name;
+  return ts8.isElementAccessExpression(expression) && expression.expression.kind === ts8.SyntaxKind.ThisKeyword && Boolean(expression.argumentExpression && ts8.isStringLiteralLike(expression.argumentExpression) && expression.argumentExpression.text === name);
 }
 function nodeWritesThisProperty(node, name) {
-  if (ts7.isBinaryExpression(node))
+  if (ts8.isBinaryExpression(node))
     return assignmentOperator2(node.operatorToken.kind) && thisPropertyWrite(node.left, name);
-  if (ts7.isPrefixUnaryExpression(node) || ts7.isPostfixUnaryExpression(node))
+  if (ts8.isPrefixUnaryExpression(node) || ts8.isPostfixUnaryExpression(node))
     return mutationUnary2(node) && thisPropertyWrite(node.operand, name);
-  return ts7.isDeleteExpression(node) && thisPropertyWrite(node.expression, name);
+  return ts8.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;
+  const flags = ts8.getCombinedModifierFlags(node);
+  if ((flags & (ts8.ModifierFlags.Private | ts8.ModifierFlags.Readonly)) === 0 || !ts8.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);
+    if (!written) ts8.forEachChild(child, visit);
   };
   visit(node.parent);
   return !written;
 }
 function collectPropertyInstance(collection, node) {
-  if (!ts7.isPropertyDeclaration(node)) return;
+  if (!ts8.isPropertyDeclaration(node)) return;
   const initializer = node.initializer;
-  if (!initializer || !ts7.isNewExpression(initializer) || !ts7.isIdentifier(initializer.expression)) return;
+  if (!initializer || !ts8.isNewExpression(initializer) || !ts8.isIdentifier(initializer.expression)) return;
   const name = propertyName2(node.name);
   if (name && stableProperty(node, name)) rememberInstance(
     collection,
@@ -1825,7 +1945,7 @@ function collectDerivedSymbolContexts(collection) {
     collectProxy(collection, node);
     collectVariableInstance(collection, node);
     collectPropertyInstance(collection, node);
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(collection.source);
 }
@@ -1836,51 +1956,51 @@ function lineOf2(source, pos) {
 }
 function nameOf(node) {
   if (!node) return void 0;
-  if (ts8.isIdentifier(node) || ts8.isStringLiteral(node) || ts8.isNumericLiteral(node)) return node.text;
+  if (ts9.isIdentifier(node) || ts9.isStringLiteral(node) || ts9.isNumericLiteral(node)) return node.text;
   return void 0;
 }
 function isFunctionLike(node) {
-  return ts8.isFunctionDeclaration(node) || ts8.isMethodDeclaration(node) || ts8.isFunctionExpression(node) || ts8.isArrowFunction(node);
+  return ts9.isFunctionDeclaration(node) || ts9.isMethodDeclaration(node) || ts9.isFunctionExpression(node) || ts9.isArrowFunction(node);
 }
 function exported(node) {
-  return Boolean(ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Export);
+  return Boolean(ts9.getCombinedModifierFlags(node) & ts9.ModifierFlags.Export);
 }
 function defaultExported(node) {
   return Boolean(
-    ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Default
+    ts9.getCombinedModifierFlags(node) & ts9.ModifierFlags.Default
   );
 }
 function isPublicClassMethod(node) {
-  const flags = ts8.getCombinedModifierFlags(node);
-  return (flags & ts8.ModifierFlags.Private) === 0 && (flags & ts8.ModifierFlags.Protected) === 0;
+  const flags = ts9.getCombinedModifierFlags(node);
+  return (flags & ts9.ModifierFlags.Private) === 0 && (flags & ts9.ModifierFlags.Protected) === 0;
 }
 function exportDeclarations(source) {
   const exports = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (ts8.isExportDeclaration(node) && node.exportClause && ts8.isNamedExports(node.exportClause)) {
+    if (ts9.isExportDeclaration(node) && node.exportClause && ts9.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) exports.set((el.propertyName ?? el.name).text, el.name.text);
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return exports;
 }
 function isObjectFunction(node) {
-  return ts8.isFunctionExpression(node) || ts8.isArrowFunction(node) || ts8.isMethodDeclaration(node);
+  return ts9.isFunctionExpression(node) || ts9.isArrowFunction(node) || ts9.isMethodDeclaration(node);
 }
 function requireSource(expr) {
-  if (!ts8.isCallExpression(expr) || !ts8.isIdentifier(expr.expression) || expr.expression.text !== "require") return void 0;
+  if (!ts9.isCallExpression(expr) || !ts9.isIdentifier(expr.expression) || expr.expression.text !== "require") return void 0;
   const first = expr.arguments[0];
-  return first && ts8.isStringLiteral(first) ? first.text : void 0;
+  return first && ts9.isStringLiteral(first) ? first.text : void 0;
 }
 function bindingLocalName(name, initializer) {
-  if (ts8.isIdentifier(name)) return name.text;
-  if (initializer && ts8.isIdentifier(initializer)) return initializer.text;
+  if (ts9.isIdentifier(name)) return name.text;
+  if (initializer && ts9.isIdentifier(initializer)) return initializer.text;
   return void 0;
 }
 function objectPatternAliases(pattern, parameter, source, lineNode) {
   return pattern.elements.flatMap((element) => {
-    if (element.dotDotDotToken || ts8.isObjectBindingPattern(element.name) || ts8.isArrayBindingPattern(element.name)) return [];
+    if (element.dotDotDotToken || ts9.isObjectBindingPattern(element.name) || ts9.isArrayBindingPattern(element.name)) return [];
     const property = element.propertyName ? nameOf(element.propertyName) : nameOf(element.name);
     if (!property) return [];
     const local = bindingLocalName(element.name, element.initializer);
@@ -1888,21 +2008,21 @@ function objectPatternAliases(pattern, parameter, source, lineNode) {
   });
 }
 function parameterPropertyAliases(fn, source) {
-  const parameterNames = new Set(fn.parameters.flatMap((param) => ts8.isIdentifier(param.name) ? [param.name.text] : []));
+  const parameterNames = new Set(fn.parameters.flatMap((param) => ts9.isIdentifier(param.name) ? [param.name.text] : []));
   if (!fn.body || parameterNames.size === 0) return [];
   const aliases = [];
   const addFromAssignment = (left, right, node) => {
-    if (!ts8.isObjectLiteralExpression(left) || !ts8.isIdentifier(right) || !parameterNames.has(right.text)) return;
+    if (!ts9.isObjectLiteralExpression(left) || !ts9.isIdentifier(right) || !parameterNames.has(right.text)) return;
     for (const prop of left.properties) {
-      if (!ts8.isPropertyAssignment(prop)) continue;
+      if (!ts9.isPropertyAssignment(prop)) continue;
       const property = nameOf(prop.name);
-      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)) });
+      if (property && ts9.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 (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);
+    if (ts9.isVariableDeclaration(node) && ts9.isObjectBindingPattern(node.name) && node.initializer && ts9.isIdentifier(node.initializer) && parameterNames.has(node.initializer.text)) aliases.push(...objectPatternAliases(node.name, node.initializer.text, source, node));
+    if (ts9.isBinaryExpression(node) && node.operatorToken.kind === ts9.SyntaxKind.EqualsToken) addFromAssignment(ts9.isParenthesizedExpression(node.left) ? node.left.expression : node.left, node.right, node);
+    ts9.forEachChild(node, visit);
   };
   visit(fn.body);
   const seen = /* @__PURE__ */ new Set();
@@ -1915,10 +2035,10 @@ function parameterPropertyAliases(fn, source) {
 }
 function parameterBindings(params) {
   return params.flatMap((param, index) => {
-    if (ts8.isIdentifier(param.name)) return [{ index, kind: "identifier", name: param.name.text }];
-    if (ts8.isObjectBindingPattern(param.name)) {
+    if (ts9.isIdentifier(param.name)) return [{ index, kind: "identifier", name: param.name.text }];
+    if (ts9.isObjectBindingPattern(param.name)) {
       const properties = param.name.elements.flatMap((element) => {
-        if (element.dotDotDotToken || ts8.isObjectBindingPattern(element.name) || ts8.isArrayBindingPattern(element.name)) return [];
+        if (element.dotDotDotToken || ts9.isObjectBindingPattern(element.name) || ts9.isArrayBindingPattern(element.name)) return [];
         const property = element.propertyName ? nameOf(element.propertyName) : nameOf(element.name);
         if (!property) return [];
         const local = bindingLocalName(element.name, element.initializer);
@@ -1926,8 +2046,8 @@ function parameterBindings(params) {
       });
       return properties.length > 0 ? [{ index, kind: "object_pattern", properties }] : [];
     }
-    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 }] : []);
+    if (ts9.isArrayBindingPattern(param.name)) {
+      const elements = param.name.elements.flatMap((element, elementIndex) => ts9.isBindingElement(element) && !element.dotDotDotToken && ts9.isIdentifier(element.name) ? [{ index: elementIndex, local: element.name.text }] : []);
       return elements.length > 0 ? [{ index, kind: "array_pattern", elements }] : [];
     }
     return [];
@@ -1938,9 +2058,9 @@ function symbolSourceEvidence(collection, node, options) {
   if (options.classMemberExported) return {
     source: "exported_class_member",
     exportedClass: options.parentRoot,
-    memberKind: ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Static ? "static_method" : "class_method"
+    memberKind: ts9.getCombinedModifierFlags(node) & ts9.ModifierFlags.Static ? "static_method" : "class_method"
   };
-  if (options.classContainerExported && ts8.isMethodDeclaration(node) && isPublicClassMethod(node)) return {
+  if (options.classContainerExported && ts9.isMethodDeclaration(node) && isPublicClassMethod(node)) return {
     source: "exported_class_instance_member",
     exportedClass: options.parentRoot,
     exportedClassExportKind: options.classContainerDefaultExported ? "default" : "named",
@@ -1964,8 +2084,8 @@ function executableEvidence(node, source) {
   };
 }
 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);
+  if (kind !== "method" || !parentName || !collection.exportedClasses.has(parentRoot) || !ts9.isMethodDeclaration(node)) return false;
+  return Boolean(ts9.getCombinedModifierFlags(node) & ts9.ModifierFlags.Static) && isPublicClassMethod(node);
 }
 function classExportState(collection, parentName, parentRoot) {
   return {
@@ -2062,41 +2182,41 @@ function addAliasSymbol(collection, objectName, propertyName3, node) {
 }
 function collectImportSources(collection) {
   const visit = (node) => {
-    if (ts8.isImportDeclaration(node) && ts8.isStringLiteral(node.moduleSpecifier))
+    if (ts9.isImportDeclaration(node) && ts9.isStringLiteral(node.moduleSpecifier))
       collectEsmImportSources(collection.imports, node);
-    if (ts8.isVariableStatement(node))
+    if (ts9.isVariableStatement(node))
       collectCjsImportSources(collection.imports, node);
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(collection.source);
 }
 function collectEsmImportSources(imports, node) {
-  if (!ts8.isStringLiteral(node.moduleSpecifier)) return;
+  if (!ts9.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))
+  if (named && ts9.isNamedImports(named))
     for (const item of named.elements) imports.set(item.name.text, source);
-  if (named && ts8.isNamespaceImport(named))
+  if (named && ts9.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))
+    if (ts9.isIdentifier(declaration.name))
       imports.set(declaration.name.text, source);
-    if (ts8.isObjectBindingPattern(declaration.name)) {
+    if (ts9.isObjectBindingPattern(declaration.name)) {
       for (const item of declaration.name.elements)
-        if (ts8.isIdentifier(item.name)) imports.set(item.name.text, source);
+        if (ts9.isIdentifier(item.name)) imports.set(item.name.text, 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;
+  if (!localName || !initializer || !ts9.isArrowFunction(initializer) && !ts9.isFunctionExpression(initializer)) return;
   const staticPublic = publicStaticProperty(collection, node, parentClass);
   const memberKind = propertyMemberKind(initializer, staticPublic);
   addExecutableSymbol(
@@ -2110,22 +2230,22 @@ function classPropertySymbol(collection, node, parentClass) {
   );
 }
 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;
+  const flags = ts9.getCombinedModifierFlags(node);
+  return collection.exportedClasses.has(parentClass) && Boolean(flags & ts9.ModifierFlags.Static) && (flags & ts9.ModifierFlags.Private) === 0 && (flags & ts9.ModifierFlags.Protected) === 0;
 }
 function propertyMemberKind(initializer, staticPublic) {
-  if (ts8.isArrowFunction(initializer))
+  if (ts9.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;
+  if (ts9.isMethodDeclaration(property)) return property;
+  return ts9.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))
+    if (objectIsExported && ts9.isShorthandPropertyAssignment(property))
       addAliasSymbol(collection, objectName, property.name.text, property.name);
     const callable = objectCallable(property);
     const propertyName3 = callable ? nameOf(property.name) : void 0;
@@ -2152,7 +2272,7 @@ function variableSymbols(collection, node) {
       void 0,
       exported(node) ? localName : collection.exportNames.get(localName)
     );
-    if (ts8.isObjectLiteralExpression(initializer))
+    if (ts9.isObjectLiteralExpression(initializer))
       objectLiteralSymbols(
         collection,
         localName,
@@ -2162,7 +2282,7 @@ function variableSymbols(collection, node) {
   }
 }
 function collectClassDeclaration(collection, node) {
-  if (!ts8.isClassDeclaration(node) || !node.name) return false;
+  if (!ts9.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);
@@ -2173,7 +2293,7 @@ function collectClassDeclaration(collection, node) {
   return true;
 }
 function collectMethodDeclaration(collection, node, parentClass) {
-  if (!ts8.isMethodDeclaration(node)) return false;
+  if (!ts9.isMethodDeclaration(node)) return false;
   const localName = nameOf(node.name);
   if (localName)
     addExecutableSymbol(collection, "method", localName, node, parentClass);
@@ -2182,11 +2302,11 @@ function collectMethodDeclaration(collection, node, parentClass) {
 function visitDeclaredSymbol(collection, node, parentClass) {
   if (collectClassDeclaration(collection, node)) return;
   if (collectMethodDeclaration(collection, node, parentClass)) return;
-  if (ts8.isPropertyDeclaration(node)) {
+  if (ts9.isPropertyDeclaration(node)) {
     if (parentClass) classPropertySymbol(collection, node, parentClass);
     return;
   }
-  if (ts8.isFunctionDeclaration(node) && node.name) {
+  if (ts9.isFunctionDeclaration(node) && node.name) {
     addExecutableSymbol(
       collection,
       "function",
@@ -2197,17 +2317,17 @@ function visitDeclaredSymbol(collection, node, parentClass) {
     );
     return;
   }
-  if (ts8.isVariableStatement(node)) {
+  if (ts9.isVariableStatement(node)) {
     variableSymbols(collection, node);
     return;
   }
-  ts8.forEachChild(node, (child) => visitDeclaredSymbol(collection, child, parentClass));
+  ts9.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;
+  if (!ts9.isArrowFunction(node) && !ts9.isFunctionExpression(node) || !ts9.isCallExpression(node.parent)) return false;
   const callee = symbolCallName(node.parent.expression);
   const member = callee.member ?? callee.local;
   return Boolean(member && [
@@ -2249,7 +2369,7 @@ function collectCallbackSymbols(collection) {
         }
       });
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(collection.source);
 }
@@ -2279,12 +2399,12 @@ function populateCollection(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(
+  return snapshot?.sourceFile() ?? ts9.createSourceFile(
     filePath,
     text,
-    ts8.ScriptTarget.Latest,
+    ts9.ScriptTarget.Latest,
     true,
-    filePath.endsWith(".ts") ? ts8.ScriptKind.TS : ts8.ScriptKind.JS
+    filePath.endsWith(".ts") ? ts9.ScriptKind.TS : ts9.ScriptKind.JS
   );
 }
 async function parseExecutableSymbols(repoPath, filePath, context, preparedOutboundCalls) {
@@ -2366,13 +2486,6 @@ function mergePackageSymbolEvidence(symbols, analysis) {
   });
 }
 
-// src/utils/hashing.ts
-import { createHash } from "crypto";
-import { readFile } from "fs/promises";
-function sha256Text(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-
 // src/db/package-target-invalidation.ts
 var resolverKeys = /* @__PURE__ */ new Set([
   "candidateStrategy",
@@ -2403,6 +2516,11 @@ function parsedEvidence(value) {
 function packageName(evidence) {
   return parsePackageImportReference(evidence.importBinding)?.requestedPackageName ?? void 0;
 }
+function eventPackageName(evidence) {
+  return parsePackageImportReference(
+    evidence.eventNameConstantImportBinding
+  )?.requestedPackageName ?? void 0;
+}
 function packageCallEvidenceValid(evidence) {
   const binding = record(evidence.importBinding);
   const classified = evidence.relation === "package_import" || binding?.moduleKind === "package";
@@ -2439,6 +2557,50 @@ function pendingEvidence(evidence) {
     unresolvedReason: "package_resolution_pending"
   });
 }
+function currentEventCalls(db, workspaceId, targetRepoId) {
+  const rows = db.prepare(`SELECT c.id,c.repo_id repoId,
+    c.unresolved_reason unresolvedReason,c.evidence_json evidenceJson
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=? AND r.id<>? AND r.fact_analyzer_version=?
+      AND json_extract(c.evidence_json,
+        '$.eventNameConstantImportBinding.moduleKind')='package'
+    ORDER BY c.id`).all(workspaceId, targetRepoId, ANALYZER_VERSION);
+  return rows.flatMap((row) => {
+    const evidence = parsedEvidence(row.evidenceJson);
+    return evidence && eventPackageName(evidence) && typeof row.id === "number" && typeof row.repoId === "number" ? [{
+      id: row.id,
+      repoId: row.repoId,
+      evidence,
+      unresolvedReason: typeof row.unresolvedReason === "string" ? row.unresolvedReason : null
+    }] : [];
+  });
+}
+function pendingEventEvidence(evidence) {
+  const parser = { ...evidence };
+  delete parser.eventNameConstant;
+  delete parser.eventNamePackageConstantResolution;
+  parser.eventNameUnresolvedReason = "event_name_constant_resolution_pending";
+  parser.eventNameStatus = "dynamic";
+  parser.eventNameSourceKind = "dynamic_expression";
+  parser.eventNamePlaceholderKeys = [];
+  return JSON.stringify(parser);
+}
+function resetPackageEventCalls(db, workspaceId, targetRepoId, names, batch) {
+  const update = db.prepare(`UPDATE outbound_calls SET event_name_expr=?,
+    unresolved_reason=?,evidence_json=? WHERE id=?`);
+  let matched = false;
+  for (const call of currentEventCalls(db, workspaceId, targetRepoId)) {
+    if (!names.has(eventPackageName(call.evidence) ?? "")) continue;
+    const source = call.evidence.eventNameConstantSourceExpression;
+    if (typeof source !== "string" || source.length === 0)
+      throw new Error("invalid_current_package_event_constant_evidence");
+    const reason = call.evidence.receiverClassification === "unproven" ? call.unresolvedReason : "event_name_constant_resolution_pending";
+    update.run(source, reason, pendingEventEvidence(call.evidence), call.id);
+    batch.affectedCallerRepoIds.add(call.repoId);
+    matched = true;
+  }
+  return matched;
+}
 function targetWorkspace(db, repoId) {
   const row = db.prepare(`SELECT workspace_id workspaceId,
     package_name packageName FROM repositories WHERE id=?`).get(repoId);
@@ -2473,6 +2635,13 @@ function invalidatePackageTargetFacts(db, targetRepoId, newPackageName, batch) {
     batch.affectedCallerRepoIds.add(call.repoId);
     matched = true;
   }
+  matched = resetPackageEventCalls(
+    db,
+    target.workspaceId,
+    targetRepoId,
+    names,
+    batch
+  ) || matched;
   if (matched || packageIdentityChanged(
     target.packageName,
     newPackageName
@@ -2503,6 +2672,29 @@ function finalizePackageTargetInvalidations(db, batch) {
     stale.run(workspaceId);
 }
 
+// src/db/event-surface-invalidation.ts
+function priorEventFactCount(db, repoId) {
+  const row = db.prepare(`SELECT COUNT(*) count FROM outbound_calls
+    WHERE repo_id=? AND call_type IN ('async_emit','async_subscribe')`).get(
+    repoId
+  );
+  return Number(row?.count ?? 0);
+}
+function repositoryEnvironment(db, repoId) {
+  const row = db.prepare(`SELECT environment_declarations_json value
+    FROM repositories WHERE id=?`).get(repoId);
+  return typeof row?.value === "string" ? row.value : null;
+}
+function invalidateEventSurfaceFacts(db, repoId, calls, nextEnvironmentJson) {
+  const hasNewEvents = calls.some((call) => call.callType === "async_emit" || call.callType === "async_subscribe");
+  const environmentChanged = repositoryEnvironment(db, repoId) !== nextEnvironmentJson;
+  if (!hasNewEvents && priorEventFactCount(db, repoId) === 0 && !environmentChanged) return;
+  db.prepare(`UPDATE repositories SET
+    graph_stale_reason='event_surface_facts_changed',
+    graph_stale_at=datetime('now')
+    WHERE workspace_id=(SELECT workspace_id FROM repositories WHERE id=?)`).run(repoId);
+}
+
 // src/indexer/repository-indexer.ts
 async function prepareRepositoryIndex(repo, force, instrumentation) {
   const sourceFiles = await findSourceFiles(repo.absolute_path);
@@ -2539,6 +2731,7 @@ async function prepareRepositoryIndex(repo, force, instrumentation) {
     kind: await classifyRepository(repo.absolute_path, packageFacts),
     parsed,
     packagePublicSurface: packageSurface.surface,
+    environmentDeclarations: collectEnvironmentDeclarations(sources),
     fileCount: sourceFiles.length,
     diagnosticCount: parsed.handlers.filter((handler) => handler.hasHandlerDecorator && (handler.methods.length === 0 || handler.methods.some((method) => !handlerMethodIsExecutable(method)))).length,
     skipped: false
@@ -2546,23 +2739,32 @@ async function prepareRepositoryIndex(repo, force, instrumentation) {
 }
 function publishPreparedRepositoryIndex(db, prepared, invalidations) {
   if (prepared.skipped) return;
-  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind || !prepared.packagePublicSurface)
+  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind || !prepared.packagePublicSurface || !prepared.environmentDeclarations)
     throw new Error("Prepared repository index is missing publication facts");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const repoId = prepared.repo.id;
+  const environmentJson = JSON.stringify(prepared.environmentDeclarations);
   invalidatePackageTargetFacts(
     db,
     repoId,
     prepared.packageFacts.packageName,
     invalidations
   );
+  invalidateEventSurfaceFacts(
+    db,
+    repoId,
+    prepared.parsed.calls,
+    environmentJson
+  );
   db.prepare(`UPDATE repositories SET package_name=?, package_version=?,
-    dependencies_json=?,package_public_surface_json=?,kind=?,index_status=?
+    dependencies_json=?,package_public_surface_json=?,
+    environment_declarations_json=?,kind=?,index_status=?
     WHERE id=?`).run(
     prepared.packageFacts.packageName,
     prepared.packageFacts.packageVersion,
     JSON.stringify(prepared.packageFacts.dependencies),
     JSON.stringify(prepared.packagePublicSurface),
+    environmentJson,
     prepared.kind,
     "indexing",
     repoId
@@ -2578,6 +2780,7 @@ function publishPreparedRepositoryIndex(db, prepared, invalidations) {
   insertRegistrations(db, repoId, prepared.parsed.registrations);
   insertBindings(db, repoId, prepared.parsed.bindings);
   insertCalls(db, repoId, prepared.parsed.calls);
+  insertGeneratedConstants(db, repoId, prepared.parsed.generatedConstants);
   db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
 }
 function publishOneRepository(db, prepared, invalidations) {
@@ -2620,14 +2823,22 @@ function recordIndexFailure(db, repoId, error) {
   db.prepare("INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)").run(repoId, "error", "source_read_failed", `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
 }
 async function parseAllSourceFacts(root, sources) {
-  const facts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], fileRecords: [] };
+  const facts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], generatedConstants: [], fileRecords: [] };
   for (const snapshot of sources.entries()) {
     const file = snapshot.filePath;
     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.generatedConstants.push(...generatedConstantFacts(source, file));
+      const classified = classifyOutboundCallsInSource(source, file, {
+        importedEventNameResolver: createImportedEventNameResolver(
+          sources,
+          source,
+          file
+        ),
+        eventEnvironmentReferenceResolver: createEventEnvironmentReferenceResolver(sources, source, file)
+      });
       facts.handlers.push(...await parseDecorators(root, file, sources));
       facts.registrations.push(...await parseHandlerRegistrations(root, file, sources));
       const bindings = await parseServiceBindings(root, file, sources);
@@ -2668,12 +2879,15 @@ async function findSourceFiles(root) {
       const rel = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
         if (!["node_modules", "dist", "gen", "coverage", ".git"].includes(e.name)) await walk(path5.join(dir, e.name), rel);
-      } else if (/\.(cds|ts|js)$/.test(e.name) && !isDefaultTestFile(rel)) out.push(rel);
+      } else if (isRepositoryFactInput(e.name) && !isDefaultTestFile(rel)) out.push(rel);
     }
   }
   await walk(root);
   return out.sort();
 }
+function isRepositoryFactInput(name) {
+  return /\.(cds|ts|js)$/.test(name) || ["nodemon.json", ".env", "mta.yaml", "manifest.yml"].includes(name);
+}
 function isDefaultTestFile(relativeFile) {
   const parts = relativeFile.split("/");
   if (parts.some((part) => ["test", "tests", "__tests__"].includes(part))) return true;
@@ -3249,6 +3463,332 @@ function symbolCallQuality(db) {
   };
 }
 
+// src/cli/doctor-event-quality.ts
+var eventNameReason = `COALESCE(
+  json_extract(c.evidence_json,'$.eventNameUnresolvedReason'),
+  CASE WHEN c.unresolved_reason GLOB 'dynamic_event_name_*'
+    OR c.unresolved_reason GLOB 'event_name_*'
+    THEN c.unresolved_reason END
+)`;
+function workspacePredicate(alias) {
+  return `(? IS NULL OR ${alias}.workspace_id=?)`;
+}
+function count2(value) {
+  return Number(value ?? 0);
+}
+function unresolvedEventNameExamples(db, workspaceId) {
+  return db.prepare(`SELECT r.name repositoryName,
+    c.source_file sourceFile,c.source_line sourceLine,
+    c.event_name_expr eventName,${eventNameReason} reason
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type='async_emit' AND ${workspacePredicate("r")}
+      AND ${eventNameReason} IS NOT NULL
+    ORDER BY r.name COLLATE BINARY,c.source_file COLLATE BINARY,
+      c.source_line,c.id LIMIT 5`).all(
+    workspaceId,
+    workspaceId
+  );
+}
+function eventNameResolutionQuality(db, workspaceId) {
+  const aggregate = db.prepare(`SELECT COUNT(*) total,
+    SUM(CASE WHEN reason IS NOT NULL THEN 1 ELSE 0 END) unresolved
+    FROM (SELECT ${eventNameReason} reason
+      FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+      WHERE c.call_type='async_emit' AND ${workspacePredicate("r")})`).get(
+    workspaceId,
+    workspaceId
+  );
+  const reasons = db.prepare(`SELECT ${eventNameReason} reason,COUNT(*) count
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type='async_emit' AND ${workspacePredicate("r")}
+      AND ${eventNameReason} IS NOT NULL
+    GROUP BY reason ORDER BY count DESC,reason COLLATE BINARY LIMIT 16`).all(
+    workspaceId,
+    workspaceId
+  );
+  const unresolved = count2(aggregate?.unresolved);
+  return {
+    severity: unresolved > 0 ? "warning" : "info",
+    code: "strict_event_name_resolution_quality",
+    message: "Event publication name-resolution aggregate",
+    publicationTotal: count2(aggregate?.total),
+    unresolvedPublicationCount: unresolved,
+    reasonBuckets: reasons,
+    examples: unresolvedEventNameExamples(db, workspaceId),
+    exampleCount: unresolved
+  };
+}
+function dynamicEventExamples(db, workspaceId) {
+  return db.prepare(`SELECT r.name repositoryName,c.call_type callType,
+    c.source_file sourceFile,c.source_line sourceLine,
+    e.to_kind targetKind,e.to_id targetId,e.unresolved_reason reason
+    FROM graph_edges e JOIN outbound_calls c
+      ON e.from_kind='call' AND c.id=CAST(e.from_id AS INTEGER)
+    JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type IN ('async_emit','async_subscribe')
+      AND ${workspacePredicate("r")}
+      AND (e.to_kind='event_candidate'
+        OR e.edge_type='DYNAMIC_EDGE_CANDIDATE')
+    ORDER BY r.name COLLATE BINARY,c.source_file COLLATE BINARY,
+      c.source_line,c.id LIMIT 5`).all(
+    workspaceId,
+    workspaceId
+  );
+}
+function dynamicEventQuality(db, workspaceId) {
+  const row = db.prepare(`SELECT
+    COUNT(DISTINCT CASE WHEN e.to_kind='event_candidate'
+      THEN e.workspace_id || ':' || e.to_id END) eventCandidateNodeCount,
+    COUNT(*) dynamicEventEdgeCount,
+    SUM(CASE WHEN json_array_length(e.evidence_json,
+      '$.eventTemplateResolution.placeholders')>0 THEN 1 ELSE 0 END)
+      variableRecoverableCount
+    FROM graph_edges e JOIN outbound_calls c
+      ON e.from_kind='call' AND c.id=CAST(e.from_id AS INTEGER)
+    JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type IN ('async_emit','async_subscribe')
+      AND ${workspacePredicate("r")}
+      AND (e.to_kind='event_candidate'
+        OR e.edge_type='DYNAMIC_EDGE_CANDIDATE')`).get(
+    workspaceId,
+    workspaceId
+  );
+  const total = count2(row?.dynamicEventEdgeCount);
+  const recoverable = count2(row?.variableRecoverableCount);
+  return {
+    severity: total > 0 ? "warning" : "info",
+    code: "strict_event_dynamic_candidate_quality",
+    message: "Dynamic event candidate aggregate",
+    eventCandidateNodeCount: count2(row?.eventCandidateNodeCount),
+    dynamicEventEdgeCount: total,
+    eventCandidateCount: total,
+    variableRecoverableCount: recoverable,
+    nonVariableRecoverableCount: Math.max(0, total - recoverable),
+    examples: dynamicEventExamples(db, workspaceId),
+    exampleCount: total
+  };
+}
+function unmatchedPublicationRows(db, workspaceId) {
+  return db.prepare(`SELECT r.name repositoryName,c.source_file sourceFile,
+    c.source_line sourceLine,e.to_id eventName
+    FROM graph_edges e JOIN outbound_calls c
+      ON e.from_kind='call' AND c.id=CAST(e.from_id AS INTEGER)
+    JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type='async_emit' AND e.edge_type='HANDLER_EMITS_EVENT'
+      AND e.to_kind='event' AND ${workspacePredicate("r")}
+      AND NOT EXISTS (SELECT 1 FROM graph_edges subscription
+        WHERE subscription.workspace_id=e.workspace_id
+          AND subscription.generation=e.generation
+          AND subscription.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+          AND subscription.from_kind='event'
+          AND subscription.from_id=e.to_id)
+    ORDER BY r.name COLLATE BINARY,c.source_file COLLATE BINARY,
+      c.source_line,c.id LIMIT 5`).all(
+    workspaceId,
+    workspaceId
+  );
+}
+function unmatchedPublicationQuality(db, workspaceId) {
+  const row = db.prepare(`SELECT COUNT(*) count
+    FROM graph_edges e JOIN outbound_calls c
+      ON e.from_kind='call' AND c.id=CAST(e.from_id AS INTEGER)
+    JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type='async_emit' AND e.edge_type='HANDLER_EMITS_EVENT'
+      AND e.to_kind='event' AND ${workspacePredicate("r")}
+      AND NOT EXISTS (SELECT 1 FROM graph_edges subscription
+        WHERE subscription.workspace_id=e.workspace_id
+          AND subscription.generation=e.generation
+          AND subscription.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+          AND subscription.from_kind='event'
+          AND subscription.from_id=e.to_id)`).get(workspaceId, workspaceId);
+  const total = count2(row?.count);
+  return {
+    severity: total > 0 ? "warning" : "info",
+    code: "strict_event_publication_without_subscription_quality",
+    message: "Resolved event publications without a matching subscription",
+    unmatchedPublicationCount: total,
+    examples: unmatchedPublicationRows(db, workspaceId),
+    exampleCount: total
+  };
+}
+function unmatchedSubscriptionRows(db, workspaceId) {
+  return db.prepare(`SELECT COALESCE(json_extract(e.evidence_json,
+      '$.subscriptionConsumerRepositoryName'),
+      json_extract(e.evidence_json,'$.repositoryName')) repositoryName,
+    json_extract(e.evidence_json,'$.sourceFile') sourceFile,
+    json_extract(e.evidence_json,'$.sourceLine') sourceLine,
+    e.from_id eventName,
+    json_extract(c.evidence_json,'$.subscriptionLoopRegistrationStatus')
+      loopRegistrationStatus,
+    json_extract(c.evidence_json,'$.subscriptionLoopRegistrationCount')
+      loopRegistrationCount
+    FROM graph_edges e LEFT JOIN outbound_calls c
+      ON c.id=CAST(json_extract(e.evidence_json,'$.subscribeCallId') AS INTEGER)
+    WHERE e.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+      AND ${workspacePredicate("e")}
+      AND NOT EXISTS (SELECT 1 FROM graph_edges publication
+        WHERE publication.workspace_id=e.workspace_id
+          AND publication.generation=e.generation
+          AND publication.edge_type='HANDLER_EMITS_EVENT'
+          AND publication.to_kind='event'
+          AND publication.to_id=e.from_id)
+    ORDER BY repositoryName COLLATE BINARY,sourceFile COLLATE BINARY,
+      sourceLine,e.id LIMIT 5`).all(
+    workspaceId,
+    workspaceId
+  );
+}
+function unmatchedSubscriptionQuality(db, workspaceId) {
+  const row = db.prepare(`SELECT COUNT(*) siteCount,
+    SUM(CASE
+      WHEN json_extract(c.evidence_json,
+        '$.subscriptionLoopRegistrationStatus')='enumerated'
+        THEN CAST(json_extract(c.evidence_json,
+          '$.subscriptionLoopRegistrationCount') AS INTEGER)
+      WHEN json_extract(c.evidence_json,
+        '$.subscriptionLoopRegistrationStatus')='unresolved' THEN 0
+      ELSE 1 END) count,
+    SUM(CASE WHEN json_extract(c.evidence_json,
+      '$.subscriptionLoopRegistrationStatus')='unresolved'
+      THEN 1 ELSE 0 END) unknownMultiplicitySiteCount
+    FROM graph_edges e LEFT JOIN outbound_calls c
+      ON c.id=CAST(json_extract(e.evidence_json,'$.subscribeCallId') AS INTEGER)
+    WHERE e.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+      AND ${workspacePredicate("e")}
+      AND NOT EXISTS (SELECT 1 FROM graph_edges publication
+        WHERE publication.workspace_id=e.workspace_id
+          AND publication.generation=e.generation
+          AND publication.edge_type='HANDLER_EMITS_EVENT'
+          AND publication.to_kind='event'
+          AND publication.to_id=e.from_id)`).get(workspaceId, workspaceId);
+  const total = count2(row?.count);
+  const siteCount = count2(row?.siteCount);
+  return {
+    severity: siteCount > 0 ? "warning" : "info",
+    code: "strict_event_subscription_without_publication_quality",
+    message: "Event subscriptions without a matching publication",
+    unmatchedSubscriptionCount: total,
+    unmatchedSubscriptionSiteCount: siteCount,
+    unknownMultiplicitySiteCount: count2(row?.unknownMultiplicitySiteCount),
+    examples: unmatchedSubscriptionRows(db, workspaceId),
+    exampleCount: siteCount
+  };
+}
+function receiverProofQuality(db, workspaceId) {
+  const row = db.prepare(`SELECT COUNT(*) eventTotal,
+    SUM(CASE WHEN json_extract(c.evidence_json,
+      '$.receiverClassification')='cap_evidence' THEN 1 ELSE 0 END) proven,
+    SUM(CASE WHEN json_extract(c.evidence_json,
+      '$.receiverClassification')='name_fallback' THEN 1 ELSE 0 END)
+      nameFallback,
+    SUM(CASE WHEN json_extract(c.evidence_json,
+      '$.receiverClassification')='unproven' THEN 1 ELSE 0 END) unproven
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type IN ('async_emit','async_subscribe')
+      AND ${workspacePredicate("r")}`).get(workspaceId, workspaceId);
+  const buckets = db.prepare(`SELECT CASE
+      WHEN json_extract(c.evidence_json,
+        '$.receiverClassification')='name_fallback' THEN 'name_fallback'
+      WHEN json_extract(c.evidence_json,
+        '$.receiverClassification')='unproven'
+        THEN COALESCE(c.unresolved_reason,'unproven')
+      ELSE 'missing' END reason,COUNT(*) count
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type IN ('async_emit','async_subscribe')
+      AND ${workspacePredicate("r")}
+      AND json_extract(c.evidence_json,'$.receiverClassification')
+        <>'cap_evidence'
+    GROUP BY reason ORDER BY count DESC,reason COLLATE BINARY LIMIT 16`).all(
+    workspaceId,
+    workspaceId
+  );
+  const questionable = count2(row?.nameFallback) + count2(row?.unproven);
+  return {
+    severity: questionable > 0 ? "warning" : "info",
+    code: "strict_event_receiver_classification_quality",
+    message: "CAP event receiver proof aggregate",
+    eventTotal: count2(row?.eventTotal),
+    proven: count2(row?.proven),
+    nameFallback: count2(row?.nameFallback),
+    unproven: count2(row?.unproven),
+    questionable,
+    reasonBuckets: buckets,
+    examples: receiverProofExamples(db, workspaceId),
+    exampleCount: questionable
+  };
+}
+function receiverProofExamples(db, workspaceId) {
+  return db.prepare(`SELECT r.name repositoryName,c.call_type callType,
+    c.source_file sourceFile,c.source_line sourceLine,
+    json_extract(c.evidence_json,'$.receiverClassification')
+      receiverClassification,
+    c.unresolved_reason reason
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE c.call_type IN ('async_emit','async_subscribe')
+      AND ${workspacePredicate("r")}
+      AND json_extract(c.evidence_json,'$.receiverClassification')
+        <>'cap_evidence'
+    ORDER BY r.name COLLATE BINARY,c.source_file COLLATE BINARY,
+      c.source_line,c.id LIMIT 5`).all(
+    workspaceId,
+    workspaceId
+  );
+}
+function shapeEnvironmentExamples(db, workspaceId) {
+  return db.prepare(`SELECT e.edge_type edgeType,e.from_id fromId,
+    e.to_kind toKind,e.to_id toId,
+    json_extract(e.evidence_json,
+      '$.eventEnvironmentResolution.status') environmentStatus,
+    json_extract(e.evidence_json,
+      '$.eventEnvironmentResolution.collisionCount') collisionCount
+    FROM graph_edges e WHERE ${workspacePredicate("e")}
+      AND (e.edge_type='EVENT_SHAPE_CANDIDATE_SUBSCRIBER'
+        OR json_extract(e.evidence_json,
+          '$.eventEnvironmentResolution.status')='ambiguous'
+        OR CAST(json_extract(e.evidence_json,
+          '$.eventEnvironmentResolution.collisionCount') AS INTEGER)>1)
+    ORDER BY e.edge_type COLLATE BINARY,e.from_id COLLATE BINARY,
+      e.to_id COLLATE BINARY,e.id LIMIT 5`).all(
+    workspaceId,
+    workspaceId
+  );
+}
+function shapeEnvironmentQuality(db, workspaceId) {
+  const row = db.prepare(`SELECT
+    SUM(CASE WHEN e.edge_type='EVENT_SHAPE_CANDIDATE_SUBSCRIBER'
+      THEN 1 ELSE 0 END) shapeCandidates,
+    SUM(CASE WHEN json_extract(e.evidence_json,
+      '$.eventEnvironmentResolution.status')='ambiguous'
+      OR CAST(json_extract(e.evidence_json,
+        '$.eventEnvironmentResolution.collisionCount') AS INTEGER)>1
+      THEN 1 ELSE 0 END) environmentAmbiguities
+    FROM graph_edges e WHERE ${workspacePredicate("e")}`).get(
+    workspaceId,
+    workspaceId
+  );
+  const shapes = count2(row?.shapeCandidates);
+  const ambiguous = count2(row?.environmentAmbiguities);
+  return {
+    severity: shapes + ambiguous > 0 ? "warning" : "info",
+    code: "strict_event_shape_environment_quality",
+    message: "Event skeleton candidate and environment ambiguity aggregate",
+    skeletonCandidateCount: shapes,
+    environmentBindingAmbiguityCount: ambiguous,
+    examples: shapeEnvironmentExamples(db, workspaceId),
+    exampleCount: shapes + ambiguous
+  };
+}
+function eventSurfaceQualityDiagnostics(db, workspaceId) {
+  return [
+    eventNameResolutionQuality(db, workspaceId),
+    dynamicEventQuality(db, workspaceId),
+    unmatchedPublicationQuality(db, workspaceId),
+    unmatchedSubscriptionQuality(db, workspaceId),
+    receiverProofQuality(db, workspaceId),
+    shapeEnvironmentQuality(db, workspaceId)
+  ];
+}
+
 // src/cli/doctor.ts
 function doctorDiagnostics(db, strict, options = {}) {
   const lifecycle = factLifecycleDiagnostic(db, options.workspaceId);
@@ -3387,7 +3927,7 @@ function parserQualityDiagnostics(db, strict, options) {
     externalHttpTargetQuality(db),
     odataInvocationResolutionQuality(db),
     ...jsonEvidenceQuality(db),
-    eventReceiverQuality(db),
+    ...eventSurfaceQualityDiagnostics(db, options.workspaceId),
     graphDynamicFlagQuality(db),
     symbol,
     dbq,
@@ -3422,10 +3962,6 @@ function outboundOwnershipQuality(db) {
   const ratio = total === 0 ? 0 : Number((without / total).toFixed(4));
   return { severity: ratio > 0.01 ? "warning" : "info", code: "strict_outbound_source_ownership_quality", message: "Outbound call source-symbol ownership aggregate", total, withoutOwnership: without, withoutOwnershipRatio: ratio, withoutOwnershipRatioThreshold: 0.01, ownerlessByType: byType, ownerlessExamples: examples };
 }
-function eventReceiverQuality(db) {
-  const row = db.prepare("SELECT SUM(CASE WHEN call_type IN ('async_emit','async_subscribe') THEN 1 ELSE 0 END) eventTotal, SUM(CASE WHEN call_type IN ('async_emit','async_subscribe') AND (json_extract(evidence_json,'$.receiverClassification') IS NULL OR json_extract(evidence_json,'$.receiverClassification') <> 'cap_evidence') THEN 1 ELSE 0 END) questionable FROM outbound_calls").get();
-  return { severity: Number(row.questionable ?? 0) > 0 ? "warning" : "info", code: "strict_event_receiver_classification_quality", message: "CAP event receiver classification aggregate", eventTotal: Number(row.eventTotal ?? 0), questionable: Number(row.questionable ?? 0) };
-}
 function graphDynamicFlagQuality(db) {
   const row = db.prepare("SELECT COUNT(*) count FROM graph_edges WHERE status='terminal' AND is_dynamic=1").get();
   return { severity: Number(row.count ?? 0) > 0 ? "warning" : "info", code: "strict_graph_dynamic_flag_consistency", message: "Graph dynamic flag consistency aggregate", dynamicTerminalEdges: Number(row.count ?? 0) };
@@ -3861,7 +4397,7 @@ function location(evidence) {
 function renderTraceTable(result) {
   const lines = ["Step  Type                 From                                To                                  Evidence"];
   for (const e of result.edges) {
-    lines.push(`${String(e.step).padEnd(5)} ${e.type.padEnd(20)} ${e.from.slice(0, 34).padEnd(35)} ${e.to.slice(0, 35).padEnd(36)} ${location(e.evidence)}`);
+    lines.push(`${String(e.step).padEnd(5)} ${e.type.padEnd(20)} ${e.from.slice(0, 34).padEnd(35)} ${e.to.slice(0, 35).padEnd(36)} ${evidenceSummary(e.evidence)}`);
     if (e.unresolvedReason)
       lines.push(...hintLines(e.evidence).map((hint) => `      ${hint}`));
   }
@@ -3869,6 +4405,13 @@ function renderTraceTable(result) {
   return `${lines.join("\n")}
 `;
 }
+function evidenceSummary(evidence) {
+  const labels = [
+    typeof evidence.dispatchScope === "string" ? `scope=${evidence.dispatchScope}` : void 0,
+    typeof evidence.dispatchCertainty === "string" ? `certainty=${evidence.dispatchCertainty}` : void 0
+  ].filter((value) => Boolean(value));
+  return labels.length > 0 ? `${location(evidence)} [${labels.join(",")}]` : location(evidence);
+}
 function diagnosticLines(diagnostic) {
   const first = `${String(diagnostic.severity ?? "info")} ${String(diagnostic.code ?? "diagnostic")} ${String(diagnostic.message ?? "")}`;
   const details = diagnosticDetailLines(diagnostic);
@@ -3906,8 +4449,8 @@ function hintLines(evidence) {
 }
 function dynamicHintLines(evidence) {
   const exploration = isRecord(evidence.dynamicTargetExploration) ? evidence.dynamicTargetExploration : evidence;
-  const count2 = numberValue(exploration.candidateCount);
-  if (count2 === 0) return [];
+  const count3 = numberValue(exploration.candidateCount);
+  if (count3 === 0) return [];
   const shown = numberValue(exploration.shownCandidateCount);
   const omitted = numberValue(exploration.omittedCandidateCount);
   const rejected = numberValue(exploration.rejectedCandidateCount);
@@ -3915,7 +4458,7 @@ function dynamicHintLines(evidence) {
     `viable candidates: ${shown} shown, ${omitted} omitted; rejected: ${rejected}`
   ];
   lines.push(...varSetHints(exploration.suggestedVarSets));
-  if (omitted > 0 || rejected > 0 || shown < count2)
+  if (omitted > 0 || rejected > 0 || shown < count3)
     lines.push("use --dynamic-mode candidates --max-dynamic-candidates 20 to explore candidate branches");
   return lines;
 }
@@ -3985,9 +4528,9 @@ function diagnosticLocation(diagnostic) {
 }
 function compactMessage(diagnostic) {
   const message = String(diagnostic.message ?? "");
-  const count2 = typeof diagnostic.count === "number" ? ` count=${diagnostic.count}` : "";
+  const count3 = typeof diagnostic.count === "number" ? ` count=${diagnostic.count}` : "";
   const total = typeof diagnostic.total === "number" ? ` total=${diagnostic.total}` : "";
-  return `${message}${count2}${total}`.trim();
+  return `${message}${count3}${total}`.trim();
 }
 function suggestedHintLines(diagnostic) {
   const direct = cliHints(diagnostic.suggestedHints);
@@ -4348,7 +4891,7 @@ function registerLinkCommand(program) {
       const upgradeWarnings = linkUpgradeWarnings(db, workspaceId);
       writeStdout(
         `${upgradeWarnings.length ? `Warnings: ${upgradeWarnings.map((item) => String(item.code)).join(", ")}. Run service-flow doctor --strict for remediation.
-` : ""}Linked ${r.edgeCount} edges: ${r.remoteResolvedCount} remote operation calls resolved, ${r.localResolvedCount} local operation calls resolved, ${r.unresolvedCount} unresolved operation calls, ${r.ambiguousCount} ambiguous operation calls, ${r.dynamicCount} dynamic operation calls, ${r.terminalCount} terminal call edges, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved, ${r.subscriptionHandlerResolvedCount} subscription handlers resolved, ${r.subscriptionHandlerAmbiguousCount} subscription handlers ambiguous, ${r.subscriptionHandlerUnresolvedCount} subscription handlers unresolved, ${r.subscriptionHandlerMissingAssociationCount} subscription handler associations missing
+` : ""}Linked ${r.edgeCount} edges: ${r.remoteResolvedCount} remote operation calls resolved, ${r.localResolvedCount} local operation calls resolved, ${r.unresolvedCount} unresolved operation calls, ${r.ambiguousCount} ambiguous operation calls, ${r.dynamicCount} dynamic operation calls, ${r.terminalCount} terminal call edges, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved, ${r.subscriptionHandlerResolvedCount} subscription handlers resolved, ${r.subscriptionHandlerAmbiguousCount} subscription handlers ambiguous, ${r.subscriptionHandlerUnresolvedCount} subscription handlers unresolved, ${r.subscriptionHandlerMissingAssociationCount} subscription handler associations missing, ${r.eventShapeCandidateCount} event shape candidates
 `
       );
     }).catch(fail)