@saptools/service-flow 0.1.69 → 0.1.72

package/src/parsers/string-constant-lookups.ts

@@ -0,0 +1,358 @@
+import ts from 'typescript';
+import { stableLocalValueReference } from './stable-local-value.js';
+import { lexicalIdentifierDeclaration } from './symbol-import-bindings.js';
+
+export type StaticStringConstantKind =
+  | 'const_identifier'
+  | 'enum_member'
+  | 'const_object_property';
+
+export interface StaticStringConstant {
+  key: string;
+  value: string;
+  kind: StaticStringConstantKind;
+  containerName?: string;
+  memberName?: string;
+  sourceFile: string;
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  valueStartOffset: number;
+  valueEndOffset: number;
+  exported: boolean;
+  stable: boolean;
+}
+
+export interface StaticStringRefusal {
+  key: string;
+  kind: StaticStringConstantKind;
+  containerName?: string;
+  memberName?: string;
+  sourceFile: string;
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  exported: boolean;
+  stable: boolean;
+  reason: 'event_name_constant_member_not_string'
+    | 'event_name_constant_container_mutable';
+}
+
+export interface StringConstantLookups {
+  identifiers: Map<string, StaticStringConstant>;
+  enumMembers: Map<string, StaticStringConstant>;
+  objectProperties: Map<string, StaticStringConstant>;
+  refusedMembers: Map<string, StaticStringRefusal>;
+}
+
+export type StaticStringLookupResult =
+  | { status: 'resolved'; constant: StaticStringConstant }
+  | { status: 'refused'; reason: string }
+  | { status: 'not_found' };
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    return unwrapExpression(expression.expression);
+  return expression;
+}
+
+function stringValue(
+  expression: ts.Expression | undefined,
+): { value: string; node: ts.Expression } | undefined {
+  if (!expression) return undefined;
+  const value = unwrapExpression(expression);
+  return ts.isStringLiteralLike(value)
+    ? { value: value.text, node: value } : undefined;
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name) ? name.text : undefined;
+}
+
+function exportedNames(source: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const statement of source.statements) {
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier
+      || !statement.exportClause
+      || !ts.isNamedExports(statement.exportClause)) continue;
+    for (const element of statement.exportClause.elements)
+      names.add(element.propertyName?.text ?? element.name.text);
+  }
+  return names;
+}
+
+function hasExportModifier(node: ts.Node): boolean {
+  return ts.canHaveModifiers(node)
+    && Boolean(ts.getModifiers(node)?.some((modifier) =>
+      modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+
+function staticFact(
+  source: ts.SourceFile,
+  key: string,
+  value: { value: string; node: ts.Expression },
+  declaration: ts.Node,
+  fields: Pick<StaticStringConstant, 'kind' | 'exported' | 'stable'>
+    & Partial<Pick<StaticStringConstant, 'containerName' | 'memberName'>>,
+): StaticStringConstant {
+  return {
+    key,
+    value: value.value,
+    sourceFile: source.fileName,
+    declarationStartOffset: declaration.getStart(source),
+    declarationEndOffset: declaration.getEnd(),
+    valueStartOffset: value.node.getStart(source),
+    valueEndOffset: value.node.getEnd(),
+    ...fields,
+  };
+}
+
+function refusalFact(
+  source: ts.SourceFile,
+  key: string,
+  declaration: ts.Node,
+  fields: Pick<StaticStringRefusal,
+    'kind' | 'exported' | 'stable' | 'reason'>
+    & Partial<Pick<StaticStringRefusal, 'containerName' | 'memberName'>>,
+): StaticStringRefusal {
+  return {
+    key,
+    sourceFile: source.fileName,
+    declarationStartOffset: declaration.getStart(source),
+    declarationEndOffset: declaration.getEnd(),
+    ...fields,
+  };
+}
+
+function collectEnum(
+  source: ts.SourceFile,
+  statement: ts.EnumDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  const stable = stableLocalValueReference(source, statement.name);
+  const exported = hasExportModifier(statement)
+    || exports.has(statement.name.text);
+  for (const member of statement.members) {
+    const memberName = propertyName(member.name);
+    if (!memberName) continue;
+    const key = `${statement.name.text}.${memberName}`;
+    const value = stringValue(member.initializer);
+    if (!stable) lookups.refusedMembers.set(key, refusalFact(
+      source, key, member, {
+        kind: 'enum_member', containerName: statement.name.text,
+        memberName, exported, stable,
+        reason: 'event_name_constant_container_mutable',
+      },
+    ));
+    else if (!value) lookups.refusedMembers.set(key, refusalFact(
+      source, key, member, {
+        kind: 'enum_member', containerName: statement.name.text,
+        memberName, exported, stable,
+        reason: 'event_name_constant_member_not_string',
+      },
+    ));
+    else lookups.enumMembers.set(key, staticFact(
+      source, key, value, member, {
+        kind: 'enum_member',
+        containerName: statement.name.text,
+        memberName,
+        exported,
+        stable,
+      },
+    ));
+  }
+}
+
+function objectLiteral(
+  expression: ts.Expression,
+): ts.ObjectLiteralExpression | undefined {
+  const value = unwrapExpression(expression);
+  return ts.isObjectLiteralExpression(value) ? value : undefined;
+}
+
+function collectObject(
+  source: ts.SourceFile,
+  statement: ts.VariableStatement,
+  declaration: ts.VariableDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+  const object = objectLiteral(declaration.initializer);
+  if (!object) return;
+  const stable = stableLocalValueReference(source, declaration.name);
+  const exported = hasExportModifier(statement)
+    || exports.has(declaration.name.text);
+  for (const property of object.properties) {
+    if (!ts.isPropertyAssignment(property)) continue;
+    const memberName = propertyName(property.name);
+    if (!memberName) continue;
+    const key = `${declaration.name.text}.${memberName}`;
+    const value = stringValue(property.initializer);
+    if (!stable) lookups.refusedMembers.set(key, refusalFact(
+      source, key, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text, memberName,
+        exported, stable,
+        reason: 'event_name_constant_container_mutable',
+      },
+    ));
+    else if (!value) lookups.refusedMembers.set(key, refusalFact(
+      source, key, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text, memberName,
+        exported, stable,
+        reason: 'event_name_constant_member_not_string',
+      },
+    ));
+    else lookups.objectProperties.set(key, staticFact(
+      source, key, value, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text,
+        memberName,
+        exported,
+        stable,
+      },
+    ));
+  }
+}
+
+function collectIdentifier(
+  source: ts.SourceFile,
+  statement: ts.VariableStatement,
+  declaration: ts.VariableDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+  const value = stringValue(declaration.initializer);
+  if (!value) return;
+  const key = declaration.name.text;
+  lookups.identifiers.set(key, staticFact(
+    source, key, value, declaration, {
+      kind: 'const_identifier',
+      exported: hasExportModifier(statement) || exports.has(key),
+      stable: true,
+    },
+  ));
+}
+
+export function collectStringConstantLookups(
+  source: ts.SourceFile,
+): StringConstantLookups {
+  const lookups: StringConstantLookups = {
+    identifiers: new Map(),
+    enumMembers: new Map(),
+    objectProperties: new Map(),
+    refusedMembers: new Map(),
+  };
+  const exports = exportedNames(source);
+  for (const statement of source.statements) {
+    if (ts.isEnumDeclaration(statement))
+      collectEnum(source, statement, exports, lookups);
+    if (!ts.isVariableStatement(statement)
+      || (statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      collectIdentifier(source, statement, declaration, exports, lookups);
+      collectObject(source, statement, declaration, exports, lookups);
+    }
+  }
+  return lookups;
+}
+
+export function resolveStringConstant(
+  expression: ts.Expression,
+  lookups: StringConstantLookups,
+): StaticStringLookupResult {
+  const value = unwrapExpression(expression);
+  if (ts.isIdentifier(value)) {
+    const constant = lookups.identifiers.get(value.text);
+    return constant && constantReferenceMatches(value, constant)
+      ? { status: 'resolved', constant } : { status: 'not_found' };
+  }
+  if (ts.isElementAccessExpression(value)
+    && ts.isIdentifier(value.expression)) {
+    const prefix = `${value.expression.text}.`;
+    const known = [
+      ...lookups.enumMembers.keys(),
+      ...lookups.objectProperties.keys(),
+      ...lookups.refusedMembers.keys(),
+    ].some((key) => key.startsWith(prefix));
+    return known && constantContainerMatches(
+      value.expression, lookups, prefix,
+    ) ? {
+      status: 'refused',
+      reason: 'event_name_constant_container_ambiguous',
+    } : { status: 'not_found' };
+  }
+  if (!ts.isPropertyAccessExpression(value)
+    || value.questionDotToken || !ts.isIdentifier(value.expression))
+    return { status: 'not_found' };
+  const key = `${value.expression.text}.${value.name.text}`;
+  const constant = lookups.enumMembers.get(key)
+    ?? lookups.objectProperties.get(key);
+  if (constant && constantReferenceMatches(value.expression, constant))
+    return { status: 'resolved', constant };
+  const reason = lookups.refusedMembers.get(key);
+  return reason && refusalReferenceMatches(value.expression, reason)
+    ? { status: 'refused', reason: reason.reason }
+    : constant || reason ? {
+        status: 'refused',
+        reason: 'event_name_constant_container_ambiguous',
+      } : { status: 'not_found' };
+}
+
+function declarationContains(
+  identifier: ts.Identifier,
+  startOffset: number,
+  endOffset: number,
+): boolean {
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration) return false;
+  const owner = declaration.parent;
+  return owner.getSourceFile() === identifier.getSourceFile()
+    && owner.getStart(identifier.getSourceFile()) <= startOffset
+    && owner.getEnd() >= endOffset;
+}
+
+function constantReferenceMatches(
+  identifier: ts.Identifier,
+  constant: StaticStringConstant,
+): boolean {
+  return declarationContains(
+    identifier,
+    constant.declarationStartOffset,
+    constant.declarationEndOffset,
+  );
+}
+
+function refusalReferenceMatches(
+  identifier: ts.Identifier,
+  refusal: StaticStringRefusal,
+): boolean {
+  return declarationContains(
+    identifier,
+    refusal.declarationStartOffset,
+    refusal.declarationEndOffset,
+  );
+}
+
+function constantContainerMatches(
+  identifier: ts.Identifier,
+  lookups: StringConstantLookups,
+  prefix: string,
+): boolean {
+  const constants = [
+    ...lookups.enumMembers.values(),
+    ...lookups.objectProperties.values(),
+  ].filter((item) => item.key.startsWith(prefix));
+  const refusals = [...lookups.refusedMembers.values()]
+    .filter((item) => item.key.startsWith(prefix));
+  return [...constants, ...refusals].some((item) =>
+    declarationContains(
+      identifier, item.declarationStartOffset, item.declarationEndOffset,
+    ));
+}

package/src/parsers/{009-symbol-call-facts.ts → symbol-call-facts.ts}

@@ -6,18 +6,18 @@ import type {
 import {
   executableSymbolCandidates,
   selectCallOwner,
-} from './004-fact-identity.js';
+} from './fact-identity.js';
 import {
   derivedMemberImportReference,
   identifierMatchesDeclaration,
   symbolImportReference,
   type SymbolImportBinding,
   type SymbolImportReference,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 import {
   localSymbolTarget,
   type LocalSymbolTargetIdentity,
-} from './016-local-symbol-reference.js';
+} from './local-symbol-reference.js';
 
 export interface SymbolCallProxy {
   importSource: string;

package/src/parsers/{017-symbol-derived-contexts.ts → symbol-derived-contexts.ts}

@@ -3,12 +3,12 @@ import {
   symbolCallName,
   type SymbolCallProxy,
   type SymbolClassInstance,
-} from './009-symbol-call-facts.js';
+} from './symbol-call-facts.js';
 import {
   identifierMatchesDeclaration,
   symbolImportReference,
   type SymbolImportBinding,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 
 interface DerivedContextCollection {
   source: ts.SourceFile;

package/src/parsers/symbol-parser.ts

@@ -9,24 +9,24 @@ import {
 } from './outbound-call-parser.js';
 import type { RepositorySourceContext } from './ts-project.js';
 import { normalizePath } from '../utils/path-utils.js';
-import { reconcileEventSubscriptions } from './005-event-subscription-facts.js';
-import { reconcileSymbolCallOwners } from './007-source-fact-reconciliation.js';
+import { reconcileEventSubscriptions } from './event-subscription-facts.js';
+import { reconcileSymbolCallOwners } from './source-fact-reconciliation.js';
 import {
   collectSymbolImportBindings,
   type SymbolImportBinding,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 import {
   collectSymbolCallFacts,
   symbolCallName,
   type SymbolCallProxy,
   type SymbolClassInstance,
-} from './009-symbol-call-facts.js';
+} from './symbol-call-facts.js';
 import {
   executableBodyEligibility,
-} from './013-executable-body-eligibility.js';
+} from './executable-body-eligibility.js';
 import {
   collectDerivedSymbolContexts,
-} from './017-symbol-derived-contexts.js';
+} from './symbol-derived-contexts.js';
 
 function lineOf(source: ts.SourceFile, pos: number): number {
   return source.getLineAndCharacterOfPosition(pos).line + 1;

package/src/trace/{021-compact-decision-normalization.ts → compact-decision-normalization.ts}

@@ -1,9 +1,9 @@
-import { compareBinary } from './010-traversal-scope.js';
+import { compareBinary } from './traversal-scope.js';
 import type {
   CompactDecisionV1,
   CompactReferenceGroupV1,
   CompactStatus,
-} from './014-compact-contract.js';
+} from './compact-contract.js';
 
 export const COMPACT_MISSING_NAME_LIMIT = 8;
 export const COMPACT_MISSING_NAME_MAX_LENGTH = 160;

package/src/trace/{020-compact-field-projection.ts → compact-field-projection.ts}

@@ -4,7 +4,7 @@ import type {
   TraceOptions,
   TraceStart,
 } from '../types.js';
-import { compareBinary } from './010-traversal-scope.js';
+import { compareBinary } from './traversal-scope.js';
 import type {
   CompactDecisionInput,
   CompactDecisionV1,
@@ -16,7 +16,7 @@ import type {
   CompactQueryV1,
   CompactStartV1,
   CompactStatusCountsV1,
-} from './014-compact-contract.js';
+} from './compact-contract.js';
 import {
   compactMissingRemediation,
   isSafeCompactReferenceName,
@@ -24,7 +24,7 @@ import {
   projectCompactReferenceGroup,
   projectCompactMissingNames,
   type CompactMissingNameProjection,
-} from './021-compact-decision-normalization.js';
+} from './compact-decision-normalization.js';
 
 const compactDiagnosticMessages: Readonly<Record<string, string>> = {
   schema_upgrade_required: 'The database schema must be upgraded before tracing.',

package/src/trace/{024-compact-observation-decision.ts → compact-observation-decision.ts}

@@ -2,10 +2,10 @@ import type {
   CompactDecisionTargetInput,
   CompactDecisionV1,
   CompactEdgeObservation,
-} from './014-compact-contract.js';
-import { projectCompactDecision } from './020-compact-field-projection.js';
+} from './compact-contract.js';
+import { projectCompactDecision } from './compact-field-projection.js';
 import { normalizeCompactDecisionEquivalence } from
-  './021-compact-decision-normalization.js';
+  './compact-decision-normalization.js';
 
 export interface CompactDecisionNode {
   key?: string;

package/src/trace/{016-compact-projector.ts → compact-projector.ts}

@@ -1,6 +1,6 @@
 import type { Db } from '../db/connection.js';
 import { redactText } from '../utils/redaction.js';
-import { compareBinary as binaryCompare } from './010-traversal-scope.js';
+import { compareBinary as binaryCompare } from './traversal-scope.js';
 import {
   type CompactDecisionTargetInput,
   type CompactProjectedDiagnostic,
@@ -17,16 +17,16 @@ import {
   type CompactSemanticEndpoint,
   type CompactSourceSite,
   type CompactStatus,
-} from './014-compact-contract.js';
+} from './compact-contract.js';
 import {
   compactCompleteness, compactSafeCode, compactStatusCounts, compactStatusTotal,
   projectCompactDecisionTarget, projectCompactDiagnostics,
   projectCompactQuery, projectCompactStart,
-} from './020-compact-field-projection.js';
+} from './compact-field-projection.js';
 import {
   projectObservationDecision,
   type CompactDecisionNode,
-} from './024-compact-observation-decision.js';
+} from './compact-observation-decision.js';
 
 const REFERENCE_LIMIT = 5;
 

package/src/trace/{018-compact-trace.ts → compact-trace.ts}

@@ -1,8 +1,8 @@
 import type { Db } from '../db/connection.js';
 import { CURRENT_SCHEMA_VERSION } from '../db/migrations.js';
-import type { CompactGraphV1, CompactSourceContext } from './014-compact-contract.js';
-import { CompactObservationCollector } from './014-compact-contract.js';
-import { projectCompactGraph } from './016-compact-projector.js';
+import type { CompactGraphV1, CompactSourceContext } from './compact-contract.js';
+import { CompactObservationCollector } from './compact-contract.js';
+import { projectCompactGraph } from './compact-projector.js';
 import { traceWithObserver } from './trace-engine.js';
 import type { TraceOptions, TraceResult, TraceStart } from '../types.js';
 

package/src/trace/{006-contextual-projection.ts → contextual-projection.ts}

@@ -1,4 +1,4 @@
-import { projectBounded } from '../utils/000-bounded-projection.js';
+import { projectBounded } from '../utils/bounded-projection.js';
 
 export function boundedContextCandidates(values: unknown[]): {
   candidates: Array<Record<string, unknown>>;

package/src/trace/{008-contextual-runtime-state.ts → contextual-runtime-state.ts}

@@ -1,7 +1,7 @@
 import type { Db } from '../db/connection.js';
 import { normalizeODataOperationInvocationPath } from '../linker/odata-path-normalizer.js';
 import { resolveOperation, type OperationResolution } from '../linker/service-resolver.js';
-import { boundedContextCandidates } from './006-contextual-projection.js';
+import { boundedContextCandidates } from './contextual-projection.js';
 
 export interface ContextBinding {
   bindingId?: number;

package/src/trace/{001-dynamic-identity.ts → dynamic-identity.ts}

@@ -1,10 +1,10 @@
 import type { Db } from '../db/connection.js';
-import { scanPlaceholders } from '../utils/001-placeholders.js';
+import { scanPlaceholders } from '../utils/placeholders.js';
 import type {
   DynamicTargetCandidate,
   DynamicTemplates,
   DynamicVariableProvenance,
-} from './000-dynamic-target-types.js';
+} from './dynamic-target-types.js';
 
 interface RouteImplementationEvidence {
   routeRepoId?: number;

package/src/trace/{003-dynamic-references.ts → dynamic-references.ts}

@@ -2,8 +2,8 @@ import type { Db } from '../db/connection.js';
 import {
   projectBounded,
   type BoundedProjection,
-} from '../utils/000-bounded-projection.js';
-import type { DynamicVariableProvenance } from './000-dynamic-target-types.js';
+} from '../utils/bounded-projection.js';
+import type { DynamicVariableProvenance } from './dynamic-target-types.js';
 
 export interface DynamicReferenceRow {
   bindingId?: number;

package/src/trace/dynamic-targets.ts

@@ -7,25 +7,25 @@ import {
 import { normalizeODataOperationInvocationPath } from '../linker/odata-path-normalizer.js';
 import type { OperationTarget } from '../linker/service-resolver.js';
 import type { DynamicMode } from '../types.js';
-import { dynamicCandidateTargets } from './004-dynamic-candidate-sources.js';
-import { projectBounded } from '../utils/000-bounded-projection.js';
-import { uniqueIdentityDerivations } from './001-dynamic-identity.js';
+import { dynamicCandidateTargets } from './dynamic-candidate-sources.js';
+import { projectBounded } from '../utils/bounded-projection.js';
+import { uniqueIdentityDerivations } from './dynamic-identity.js';
 import {
   dynamicReferenceProvenance,
   dynamicRoutingContext,
   type DynamicReferenceRow,
   type DynamicRoutingContext,
-} from './003-dynamic-references.js';
+} from './dynamic-references.js';
 import type {
   DynamicTargetAnalysis,
   DynamicTargetCandidate,
   DynamicTemplates,
   DynamicVariableProvenance,
-} from './000-dynamic-target-types.js';
+} from './dynamic-target-types.js';
 export type {
   DynamicTargetAnalysis,
   DynamicTargetCandidate,
-} from './000-dynamic-target-types.js';
+} from './dynamic-target-types.js';
 type Templates = DynamicTemplates;
 type VariableProvenance = DynamicVariableProvenance;
 interface AnalysisInputs {

package/src/trace/{030-event-runtime-resolution.ts → event-runtime-resolution.ts}

@@ -8,12 +8,18 @@ import {
   planEventSubscriberTransitions,
   type EventSubscriberTransitionQuery,
   type PlannedEventSubscriberTransition,
-} from './011-event-subscriber-traversal.js';
+} from './event-subscriber-traversal.js';
 import type {
   TraversalScopeScheduler,
   TraversalScopeState,
-} from './010-traversal-scope.js';
+} from './traversal-scope.js';
 import type { TraceGraphRow } from './evidence.js';
+import {
+  eventMissingVariableNames,
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+  type EventSkeletonFact,
+} from '../utils/event-skeleton.js';
 
 export interface EventRuntimeResolution {
   row: TraceGraphRow;
@@ -37,6 +43,12 @@ function eventTemplate(evidence: Record<string, unknown>): string | undefined {
     ? resolution.original : undefined;
 }
 
+function eventSkeleton(
+  evidence: Record<string, unknown>,
+): EventSkeletonFact | undefined {
+  return parseEventSkeletonFact(evidence.eventSkeleton);
+}
+
 function missingReason(substitution: RuntimeSubstitution): string {
   return `Dynamic target requires runtime variable overrides: ${
     substitution.missing.join(', ')}`;
@@ -88,6 +100,10 @@ function eventEvidence(
     unresolvedReason,
     edgeType: row.edge_type,
   };
+  const skeleton = eventSkeleton(evidence);
+  const missing = eventMissingVariableNames(
+    skeleton, substitution.missing,
+  );
   return {
     ...evidence,
     runtimeSubstitutions: { eventName: substitution },
@@ -96,8 +112,10 @@ function eventEvidence(
     ),
     ...(substitution.supplied.length > 0
       ? { runtimeVariablesApplied: true } : {}),
-    ...(substitution.missing.length > 0
-      ? { missingRuntimeVariables: substitution.missing } : {}),
+    ...(missing.length > 0 ? {
+      missingRuntimeVariables: missing,
+      missingVariableCount: missing.length,
+    } : {}),
     effectiveResolution,
     linker: {
       status: effectiveResolution.status,
@@ -137,7 +155,10 @@ export function runtimeEventResolution(
   const template = eventTemplate(evidence);
   if (!template || row.to_kind === 'event' && variables === undefined)
     return undefined;
-  const substitution = substituteVariables(template, variables ?? {});
+  const skeleton = eventSkeleton(evidence);
+  const substitution = substituteVariables(
+    template, eventTemplateVariables(skeleton, variables ?? {}),
+  );
   const effectiveRow = runtimeEventRow(
     row, evidence, substitution, template,
   );