@saptools/service-flow 0.1.70 → 0.1.73

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
   ANALYZER_VERSION,
+  DEFAULT_EVENT_ENVIRONMENT_KEYS,
+  EVENT_ENVIRONMENT_KEY_CAP,
   PreparedRepositorySnapshotError,
   VERSION,
   analyzePackagePublicSurface,
@@ -8,14 +10,20 @@ import {
   bindingSite,
   classifyODataPathIntent,
   classifyOutboundCallsInSource,
+  collectEnvironmentDeclarations,
+  collectStringConstantLookups,
   collectSymbolImportBindings,
   compactTrace,
   containsSupportedOutboundCall,
   createBindingLexicalIndex,
+  createEventEnvironmentReferenceResolver,
+  createImportedEventNameResolver,
   derivedMemberImportReference,
   discoverRepositories,
+  emptyEnvironmentDeclarations,
   executableSymbolCandidates,
   factLifecycleDiagnostic,
+  generatedConstantFacts,
   identifierMatchesDeclaration,
   implementationHintSuggestions,
   insertCalls,
@@ -28,6 +36,7 @@ import {
   loadPackageJsonSnapshot,
   loadRepositorySourceContext,
   migrate,
+  normalizeEventEnvironmentKeys,
   normalizeODataOperationInvocationPath,
   normalizePath,
   parseCdsFile,
@@ -42,13 +51,16 @@ import {
   projectBoundedInOrder,
   recordPreparedSnapshotFailure,
   redactValue,
+  resolveBinding,
   selectCallOwner,
   selectVisibleBinding,
   selectorRepoAmbiguousDiagnostic,
+  sha256Text,
   stableLocalValueReference,
   symbolImportReference,
-  trace
-} from "./chunk-GSLFY6J2.js";
+  trace,
+  validEventEnvironmentKey
+} from "./chunk-32WOTGTS.js";
 
 // src/cli.ts
 import { Command, Option } from "commander";
@@ -73,10 +85,18 @@ var DEFAULT_DB_FILE = "service-flow.db";
 import fs from "fs/promises";
 import path from "path";
 import { z } from "zod";
+var environmentKeys = z.array(
+  z.string().refine(validEventEnvironmentKey)
+).min(1).max(EVENT_ENVIRONMENT_KEY_CAP).transform(
+  normalizeEventEnvironmentKeys
+);
 var schema = z.object({
   rootPath: z.string(),
   dbPath: z.string(),
   ignore: z.array(z.string()),
+  eventEnvironmentKeys: environmentKeys.default(
+    [...DEFAULT_EVENT_ENVIRONMENT_KEYS]
+  ),
   createdAt: z.string(),
   updatedAt: z.string()
 });
@@ -113,6 +133,7 @@ function createWorkspaceConfig(rootPath, dbPath, ignore = [...DEFAULT_IGNORES])
     rootPath: root,
     dbPath: path.resolve(dbPath ?? defaultDbPath(root)),
     ignore,
+    eventEnvironmentKeys: [...DEFAULT_EVENT_ENVIRONMENT_KEYS],
     createdAt: now,
     updatedAt: now
   };
@@ -250,8 +271,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 +287,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 +314,7 @@ function clearRepoFacts(db, repoId) {
     "symbol_calls",
     "handler_registrations",
     "service_bindings",
+    "generated_constants",
     "symbols",
     "diagnostics",
     "files"
@@ -299,6 +322,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 +661,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 +801,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 +898,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 +921,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 +941,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 +950,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 +1038,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 +1072,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 +1192,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 +1387,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 +1455,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 +1488,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 +1517,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 +1578,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 +1611,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 +1752,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 +1780,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 +1821,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 +1850,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 +1876,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 +1908,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 +1958,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 +1969,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 +2021,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 +2048,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 +2059,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 +2071,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 +2097,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 +2195,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 +2243,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 +2285,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 +2295,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 +2306,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 +2315,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 +2330,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 +2382,7 @@ function collectCallbackSymbols(collection) {
         }
       });
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(collection.source);
 }
@@ -2279,12 +2412,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 +2499,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 +2529,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 +2570,54 @@ 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");
+    update.run(
+      source,
+      "event_name_constant_resolution_pending",
+      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 +2652,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,8 +2689,31 @@ 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) {
+async function prepareRepositoryIndex(repo, force, instrumentation, eventEnvironmentKeys) {
   const sourceFiles = await findSourceFiles(repo.absolute_path);
   const packageSnapshot = await loadPackageJsonSnapshot(repo.absolute_path, {
     strict: true,
@@ -2516,13 +2725,23 @@ async function prepareRepositoryIndex(repo, force, instrumentation) {
     sourceFiles,
     instrumentation
   );
+  const environmentDeclarations = collectEnvironmentDeclarations(
+    sources,
+    eventEnvironmentKeys
+  );
   const fingerprint = repositoryFingerprint(
     sources,
     packageFacts,
-    packageSnapshot.rawText
+    packageSnapshot.rawText,
+    environmentDeclarations
   );
   if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
-  const parsedFacts = await parseAllSourceFacts(repo.absolute_path, sources);
+  const parsedFacts = await parseAllSourceFacts(
+    repo.absolute_path,
+    sources,
+    environmentDeclarations,
+    eventEnvironmentKeys
+  );
   const packageSurface = analyzeRepositoryPackageSurface(
     packageFacts,
     packageSnapshot.manifest,
@@ -2539,6 +2758,7 @@ async function prepareRepositoryIndex(repo, force, instrumentation) {
     kind: await classifyRepository(repo.absolute_path, packageFacts),
     parsed,
     packagePublicSurface: packageSurface.surface,
+    environmentDeclarations,
     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 +2766,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 +2807,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) {
@@ -2619,15 +2849,33 @@ function recordIndexFailure(db, repoId, error) {
   )`).run(repoId);
   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: [] };
+async function parseAllSourceFacts(root, sources, environmentDeclarations, eventEnvironmentKeys) {
+  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 });
+    facts.fileRecords.push({
+      relativePath: normalizePath(file),
+      extension: path5.extname(file),
+      sha256: sourceFactHash(snapshot, environmentDeclarations),
+      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,
+          eventEnvironmentKeys
+        )
+      });
       facts.handlers.push(...await parseDecorators(root, file, sources));
       facts.registrations.push(...await parseHandlerRegistrations(root, file, sources));
       const bindings = await parseServiceBindings(root, file, sources);
@@ -2668,18 +2916,21 @@ 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;
   return /\.(test|spec)\.[jt]s$/.test(parts.at(-1) ?? "");
 }
-function repositoryFingerprint(sources, facts, packageJsonText) {
+function repositoryFingerprint(sources, facts, packageJsonText, environmentDeclarations) {
   const normalizedFacts = {
     analyzerVersion: ANALYZER_VERSION,
     packageName: facts.packageName,
@@ -2688,13 +2939,33 @@ function repositoryFingerprint(sources, facts, packageJsonText) {
     cdsRequires: [...facts.cdsRequires].sort((a, b) => a.alias.localeCompare(b.alias)),
     scripts: Object.fromEntries(Object.entries(facts.scripts).sort()),
     includeTests: false,
+    eventEnvironmentKeys: environmentDeclarations.allowedKeys,
     packageJsonHash: sha256Text(packageJsonText)
   };
   const entries = [`facts:${JSON.stringify(normalizedFacts)}`];
   for (const snapshot of sources.entries())
-    entries.push(`${snapshot.filePath}:${sha256Text(snapshot.text)}`);
+    entries.push(
+      `${snapshot.filePath}:${sourceFactHash(snapshot, environmentDeclarations)}`
+    );
   return sha256Text(entries.join("\n"));
 }
+function sourceFactHash(snapshot, environmentDeclarations) {
+  if (!isEnvironmentFactInput(snapshot.filePath))
+    return sha256Text(snapshot.text);
+  const declarations = environmentDeclarations.declarations.filter(
+    (item) => item.sourceFile === snapshot.filePath
+  );
+  return sha256Text(JSON.stringify({
+    allowedKeys: environmentDeclarations.allowedKeys,
+    declarations
+  }));
+}
+function isEnvironmentFactInput(filePath) {
+  const name = filePath.split("/").at(-1);
+  return ["nodemon.json", ".env", "mta.yaml", "manifest.yml"].includes(
+    name ?? ""
+  );
+}
 
 // src/indexer/cds-extension-resolver.ts
 function materializeCdsExtensionOperations(db, workspaceId, excludedRepoIds = /* @__PURE__ */ new Set()) {
@@ -2874,7 +3145,12 @@ async function indexWorkspace(db, workspaceId, options) {
     rows: []
   };
   try {
-    await prepareRepositories(repos, options.force, state);
+    await prepareRepositories(
+      repos,
+      options.force,
+      state,
+      options.eventEnvironmentKeys
+    );
     return publishPreparedWorkspaceRows(
       db,
       workspaceId,
@@ -2901,10 +3177,15 @@ function selectedRepositories(db, workspaceId, repoName) {
     );
   return repos;
 }
-async function prepareRepositories(repos, force, state) {
+async function prepareRepositories(repos, force, state, eventEnvironmentKeys) {
   for (const repo of repos) {
     state.activeRepoId = repo.id;
-    const result = await prepareRepositoryIndex(repo, force);
+    const result = await prepareRepositoryIndex(
+      repo,
+      force,
+      void 0,
+      eventEnvironmentKeys
+    );
     state.rows.push(result);
     state.fileCount += result.fileCount;
     state.diagnosticCount += result.diagnosticCount;
@@ -3249,6 +3530,392 @@ 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
+)`;
+var receiverReason = `CASE
+  WHEN json_extract(c.evidence_json,
+    '$.receiverClassification')='name_fallback'
+    THEN COALESCE(json_extract(c.evidence_json,
+      '$.receiverFallbackRefusedReason'),'name_fallback')
+  WHEN json_extract(c.evidence_json,
+    '$.receiverClassification')='unproven'
+    THEN COALESCE(json_extract(c.evidence_json,
+      '$.receiverUnresolvedReason'),'unproven')
+  ELSE 'missing' 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);
+  const reasonCount = count2(db.prepare(`SELECT COUNT(DISTINCT reason) count
+    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")}
+        AND ${eventNameReason} IS NOT NULL)`).get(
+    workspaceId,
+    workspaceId
+  )?.count);
+  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,
+    reasonBucketCount: reasonCount,
+    shownReasonBucketCount: reasons.length,
+    omittedReasonBucketCount: Math.max(0, reasonCount - reasons.length),
+    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(DISTINCT json_extract(e.evidence_json,'$.subscribeCallId'))
+      siteCount,
+    SUM(CASE
+      WHEN json_extract(e.evidence_json,'$.materializedLoopEventName')
+        IS NOT NULL THEN 1
+      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) unknownMultiplicityEdgeCount
+    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);
+  const unknownSites = unknownMultiplicitySiteCount(db, workspaceId);
+  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: unknownSites,
+    examples: unmatchedSubscriptionRows(db, workspaceId),
+    exampleCount: siteCount
+  };
+}
+function unknownMultiplicitySiteCount(db, workspaceId) {
+  const row = db.prepare(`SELECT COUNT(DISTINCT
+    json_extract(e.evidence_json,'$.subscribeCallId')) count
+    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 json_extract(c.evidence_json,
+        '$.subscriptionLoopRegistrationStatus')='unresolved'
+      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);
+  return count2(row?.count);
+}
+function receiverProofAggregate(db, workspaceId) {
+  return 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);
+}
+function receiverReasonBuckets(db, workspaceId) {
+  return db.prepare(`SELECT ${receiverReason} 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
+  );
+}
+function receiverReasonBucketCount(db, workspaceId) {
+  const row = db.prepare(`SELECT COUNT(DISTINCT reason) count
+    FROM (SELECT ${receiverReason} 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')`).get(workspaceId, workspaceId);
+  return count2(row?.count);
+}
+function receiverProofQuality(db, workspaceId) {
+  const row = receiverProofAggregate(db, workspaceId);
+  const buckets = receiverReasonBuckets(db, workspaceId);
+  const bucketCount = receiverReasonBucketCount(db, 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,
+    reasonBucketCount: bucketCount,
+    shownReasonBucketCount: buckets.length,
+    omittedReasonBucketCount: Math.max(0, bucketCount - buckets.length),
+    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,
+    COALESCE(json_extract(c.evidence_json,'$.receiverUnresolvedReason'),
+      json_extract(c.evidence_json,'$.receiverFallbackRefusedReason')) reason,
+    json_array_length(json_extract(c.evidence_json,
+      '$.consideredBindingSites')) consideredBindingSiteCount
+    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 +4054,7 @@ function parserQualityDiagnostics(db, strict, options) {
     externalHttpTargetQuality(db),
     odataInvocationResolutionQuality(db),
     ...jsonEvidenceQuality(db),
-    eventReceiverQuality(db),
+    ...eventSurfaceQualityDiagnostics(db, options.workspaceId),
     graphDynamicFlagQuality(db),
     symbol,
     dbq,
@@ -3422,10 +4089,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 +4524,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 +4532,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 +4576,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 +4585,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 +4655,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);
@@ -4102,6 +4772,15 @@ function renderCompactJson(value) {
 `;
 }
 
+// src/output/repository-inspection.ts
+function projectRepositoryInspection(repository) {
+  return Object.fromEntries(
+    Object.entries(repository).filter(
+      ([key]) => key !== "environment_declarations_json"
+    )
+  );
+}
+
 // src/cli/clean.ts
 import fs6 from "fs/promises";
 import path6 from "path";
@@ -4215,7 +4894,7 @@ async function withWorkspace(workspace, fn) {
   try {
     const row = getWorkspace(db, config.rootPath);
     const workspaceId = row?.id ?? upsertWorkspace(db, config.rootPath, config.dbPath);
-    return await fn(db, workspaceId, config.rootPath);
+    return await fn(db, workspaceId, config.rootPath, config);
   } finally {
     db.close();
   }
@@ -4330,10 +5009,11 @@ function registerInitCommand(program) {
 }
 function registerIndexCommand(program) {
   program.command("index").option("--workspace <path>").option("--repo <name>").option("--force").action(
-    (opts) => void withWorkspace(opts.workspace, async (db, workspaceId) => {
+    (opts) => void withWorkspace(opts.workspace, async (db, workspaceId, _root, config) => {
       const r = await indexWorkspace(db, workspaceId, {
         repo: opts.repo,
-        force: Boolean(opts.force)
+        force: Boolean(opts.force),
+        eventEnvironmentKeys: config.eventEnvironmentKeys
       });
       const outcome = indexCommandOutcome(r);
       writeStdout(outcome.stdout);
@@ -4348,7 +5028,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, ${r.eventShapeCandidateOmittedCount} event shape candidates omitted by the link cap
 `
       );
     }).catch(fail)
@@ -4358,18 +5038,20 @@ function registerTraceCommand(program) {
   program.command("trace").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--handler <name>").option("--depth <n>", "trace depth", "25").addOption(traceFormatOption()).option("--include-external").option("--include-db").option("--include-async").option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action((opts) => void runTraceCommand(opts).catch(fail));
 }
 function listRepositoriesCommand(opts) {
-  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => writeStdout(
-    renderJson(
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    if (writeLifecycleBlock(db, workspaceId)) return;
+    writeStdout(renderJson(
       listRepositories(db, workspaceId).map((repo) => ({
         name: repo.name,
         kind: repo.kind,
         packageName: repo.package_name
       }))
-    )
-  ));
+    ));
+  });
 }
 function listServicesCommand(opts) {
   return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    if (writeLifecycleBlock(db, workspaceId)) return;
     const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
     if (selection.diagnostic) {
       writeStdout(renderJson([selection.diagnostic]));
@@ -4384,6 +5066,7 @@ function listServicesCommand(opts) {
 }
 function listOperationsCommand(opts) {
   return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    if (writeLifecycleBlock(db, workspaceId)) return;
     const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
     if (selection.diagnostic) {
       writeStdout(renderJson([selection.diagnostic]));
@@ -4404,6 +5087,7 @@ function listOperationsCommand(opts) {
 }
 function listCallsCommand(opts) {
   return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    if (writeLifecycleBlock(db, workspaceId)) return;
     const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
     if (selection.diagnostic) {
       writeStdout(renderJson([selection.diagnostic]));
@@ -4444,20 +5128,29 @@ function registerGraphCommand(program) {
 }
 function inspectRepositoryCommand(name, opts) {
   return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    if (writeLifecycleBlock(db, workspaceId)) return;
     const selection = selectRepository(db, name, workspaceId);
     writeStdout(renderJson(
-      selection.repo ?? selection.diagnostic ?? { error: "repo not found" }
+      selection.repo ? projectRepositoryInspection(selection.repo) : selection.diagnostic ?? { error: "repo not found" }
     ));
   });
 }
 function inspectOperationCommand(selector, opts) {
   return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    if (writeLifecycleBlock(db, workspaceId)) return;
     const rows = db.prepare(
       "SELECT o.* FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (o.operation_name=? OR o.operation_path=?)"
     ).all(workspaceId, selector, selector);
     writeStdout(renderJson(rows));
   });
 }
+function writeLifecycleBlock(db, workspaceId) {
+  const diagnostic = factLifecycleDiagnostic(db, workspaceId);
+  if (!diagnostic) return false;
+  writeStdout(renderJson([diagnostic]));
+  process.exitCode = 1;
+  return true;
+}
 function registerInspectCommands(program) {
   const inspect = program.command("inspect");
   inspect.command("repo").argument("<name>").option("--workspace <path>").action(