@saptools/service-flow 0.1.69 → 0.1.72

package/src/linker/{006-event-template-link.ts → event-template-link.ts}

@@ -3,6 +3,14 @@ import {
   substituteVariables,
   type RuntimeSubstitution,
 } from './dynamic-edge-resolver.js';
+import {
+  resolveEventEnvironment,
+} from './event-environment-link.js';
+import {
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+  type EventSkeletonFact,
+} from '../utils/event-skeleton.js';
 
 export interface LinkedEventTemplate {
   targetId: string;
@@ -17,8 +25,11 @@ export function linkEventTemplate(
   template: string,
   variables: Record<string, string>,
   parserReason?: string,
+  skeleton?: EventSkeletonFact,
 ): LinkedEventTemplate {
-  const substitution = substituteVariables(template, variables);
+  const substitution = substituteVariables(
+    template, eventTemplateVariables(skeleton, variables),
+  );
   const missing = substitution.missing.length > 0;
   const unsupportedDynamic = substitution.placeholders.length === 0
     && parserReason !== undefined;
@@ -47,18 +58,41 @@ export function insertEventCallEdge(
   evidence: Record<string, unknown>,
 ): { status: string; callType: string } {
   const callType = String(call.call_type);
+  const skeleton = parseEventSkeletonFact(call.event_skeleton_json);
+  const environment = resolveEventEnvironment(
+    call.event_skeleton_json,
+    call.environmentDeclarationsJson,
+    variables,
+  );
   const event = linkEventTemplate(
-    String(call.event_name_expr ?? ''), variables,
+    String(call.event_name_expr ?? ''), environment.variables,
     typeof call.unresolved_reason === 'string'
       ? call.unresolved_reason : undefined,
+    skeleton,
   );
   const edgeType = event.isDynamic
     ? 'DYNAMIC_EDGE_CANDIDATE'
     : callType === 'async_emit'
       ? 'HANDLER_EMITS_EVENT' : 'EVENT_CONSUMED_BY_HANDLER';
-  const eventEvidence = event.substitution.placeholders.length > 0
-    ? { ...evidence, eventTemplateResolution: event.substitution }
-    : evidence;
+  const eventEvidence = {
+    ...evidence,
+    dispatchScope: 'workspace_event_name_only',
+    dispatchCertainty: environment.status === 'resolved'
+      ? 'environment_declaration_exact'
+      : event.isDynamic ? 'runtime_variables_required' : 'static_name_only',
+    ...(skeleton ? { eventSkeleton: skeleton } : {}),
+    ...(event.substitution.placeholders.length > 0
+      ? { eventTemplateResolution: event.substitution } : {}),
+    ...(environment.status === 'not_applicable' ? {} : {
+      eventEnvironmentResolution: {
+        status: environment.status,
+        reason: environment.reason,
+        provenance: environment.provenance,
+      },
+    }),
+  };
+  const unresolvedReason = environment.reason
+    ?? event.unresolvedReason;
   db.prepare(`INSERT INTO graph_edges(
     workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
     confidence,evidence_json,is_dynamic,unresolved_reason,generation
@@ -66,7 +100,7 @@ export function insertEventCallEdge(
     workspaceId, edgeType, event.status, 'call', String(call.id),
     event.targetKind, event.targetId, Number(call.confidence ?? 0.2),
     JSON.stringify(eventEvidence), event.isDynamic ? 1 : 0,
-    event.unresolvedReason ?? null, generation,
+    unresolvedReason ?? null, generation,
   );
   return { status: event.status, callType };
 }

package/src/linker/external-http-target.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { projectBounded } from '../utils/000-bounded-projection.js';
+import { projectBounded } from '../utils/bounded-projection.js';
 
 export type ExternalTargetKind = 'destination' | 'static_url' | 'url_expression' | 'unknown';
 export interface ExternalHttpTarget { kind: ExternalTargetKind; toKind: 'external_destination' | 'external_endpoint'; toId: string; label: string; method?: string; dynamic: boolean; expression?: string; candidateLiteralCount?: number; shownCandidateLiteralCount?: number; omittedCandidateLiteralCount?: number; }

package/src/linker/helper-package-linker.ts

@@ -1,5 +1,5 @@
 import type { Db } from '../db/connection.js';
-import { projectBounded } from '../utils/000-bounded-projection.js';
+import { projectBounded } from '../utils/bounded-projection.js';
 
 interface RepoDependencyRow {
   id: number;

package/src/linker/{000-implementation-candidates.ts → implementation-candidates.ts}

@@ -6,7 +6,7 @@ import {
   boundedImplementationTargetIds,
   displayImplementationCandidates,
   selectedHandlerProvenance,
-} from './001-implementation-evidence-projection.js';
+} from './implementation-evidence-projection.js';
 
 interface ImplementationCandidate extends Record<string, unknown> {
   methodId: number;

package/src/linker/{001-implementation-evidence-projection.ts → implementation-evidence-projection.ts}

@@ -2,7 +2,7 @@ import {
   projectBounded,
   projectBoundedInOrder,
   type BoundedProjection,
-} from '../utils/000-bounded-projection.js';
+} from '../utils/bounded-projection.js';
 
 export interface SelectedHandlerSource {
   methodId: number;

package/src/linker/odata-path-normalizer.ts

@@ -1,7 +1,7 @@
 import {
   analyzeODataPathStructure,
   type ODataPathStructure,
-} from './005-odata-path-structure.js';
+} from './odata-path-structure.js';
 
 export interface NormalizedODataOperationPath {
   rawOperationPath: string;

package/src/linker/{005-odata-path-structure.ts → odata-path-structure.ts}

@@ -1,7 +1,7 @@
 import {
   scanPlaceholderStructure,
   type PlaceholderSpan,
-} from '../utils/001-placeholders.js';
+} from '../utils/placeholders.js';
 
 export type ODataPathStructureReason =
   | 'path_parenthesis_is_unbalanced'

package/src/linker/package-event-constant-resolver.ts

@@ -0,0 +1,298 @@
+import type { Db } from '../db/connection.js';
+import {
+  parsePackageImportReference,
+  parsePackagePublicSurfaceFact,
+} from '../parsers/package-fact-contract.js';
+import type {
+  PackagePublicSurfaceFact,
+} from '../parsers/package-public-surface.js';
+import type {
+  SymbolImportReference,
+} from '../parsers/symbol-import-bindings.js';
+
+export interface PackageEventConstantLinkSummary {
+  resolved: number;
+  ambiguous: number;
+  unresolved: number;
+}
+
+interface EventConstantCall {
+  id: number;
+  binding: SymbolImportReference;
+  evidence: Record<string, unknown>;
+  unresolvedReason?: string | null;
+}
+
+interface PackageRepository {
+  id: number;
+  surface: PackagePublicSurfaceFact;
+}
+
+export interface PackageEventConstantResolution {
+  status: 'resolved' | 'ambiguous' | 'unresolved';
+  reason?: string;
+  value?: string;
+  sourceFile?: string;
+  sourceLine?: number;
+  targetRepoId?: number;
+  modulePath?: string;
+  candidateCount: number;
+  eligibleCandidateCount: number;
+  complete: boolean;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function jsonRecord(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== 'string') return undefined;
+  try {
+    return record(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function callRows(db: Db, workspaceId: number): EventConstantCall[] {
+  const rows = db.prepare(`SELECT c.id,c.evidence_json evidenceJson,
+    c.unresolved_reason unresolvedReason
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=?
+      AND c.call_type IN ('async_emit','async_subscribe')
+      AND json_extract(c.evidence_json,
+        '$.eventNameConstantImportBinding.moduleKind')='package'
+    ORDER BY c.id`).all(workspaceId);
+  return rows.flatMap((row) => {
+    const evidence = jsonRecord(row.evidenceJson);
+    const binding = parsePackageImportReference(
+      evidence?.eventNameConstantImportBinding,
+    );
+    return typeof row.id === 'number' && evidence && binding ? [{
+      id: row.id, evidence, binding,
+      unresolvedReason: typeof row.unresolvedReason === 'string'
+        ? row.unresolvedReason : null,
+    }] : [];
+  });
+}
+
+function parseSurface(
+  value: unknown,
+  packageName: string,
+): PackagePublicSurfaceFact | undefined {
+  if (typeof value !== 'string') return undefined;
+  try {
+    return parsePackagePublicSurfaceFact(
+      JSON.parse(value) as unknown, packageName,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function repositories(
+  db: Db,
+  workspaceId: number,
+  packageName: string,
+): PackageRepository[] {
+  return db.prepare(`SELECT id,package_public_surface_json surfaceJson
+    FROM repositories WHERE workspace_id=? AND package_name=?
+    ORDER BY id`).all(workspaceId, packageName).flatMap((row) => {
+    const surface = parseSurface(row.surfaceJson, packageName);
+    return typeof row.id === 'number' && surface
+      ? [{ id: row.id, surface }] : [];
+  });
+}
+
+function failure(
+  reason: string,
+  fields: Partial<PackageEventConstantResolution> = {},
+): PackageEventConstantResolution {
+  return {
+    status: reason === 'event_name_constant_container_ambiguous'
+      ? 'ambiguous' : 'unresolved',
+    reason,
+    candidateCount: 0,
+    eligibleCandidateCount: 0,
+    complete: true,
+    ...fields,
+  };
+}
+
+function entryModule(
+  repository: PackageRepository,
+  binding: SymbolImportReference,
+): string | PackageEventConstantResolution {
+  const surface = repository.surface;
+  if (surface.status !== 'complete' || surface.omitted > 0) return failure(
+    'event_name_constant_container_ambiguous', { complete: false },
+  );
+  const matches = surface.entries.filter((entry) =>
+    entry.entry === binding.requestedModuleSubpath);
+  return matches.length === 1 && matches[0]
+    ? matches[0].modulePath
+    : failure('event_name_constant_container_ambiguous', {
+        complete: matches.length === 0 && surface.omitted === 0,
+      });
+}
+
+function moduleFile(sourceFile: string): string {
+  return sourceFile.replace(/\.(?:d\.)?(?:ts|js)$/, '');
+}
+
+function constantRows(
+  db: Db,
+  repoId: number,
+  modulePath: string,
+  publicName: string,
+): Array<Record<string, unknown>> {
+  return db.prepare(`SELECT id,source_file sourceFile,
+    source_line sourceLine,value,exported,stable,
+    resolution_status resolutionStatus,unresolved_reason unresolvedReason
+    FROM generated_constants
+    WHERE repo_id=? AND name=?
+    ORDER BY source_file COLLATE BINARY,declaration_start_offset,id`).all(
+    repoId, publicName,
+  ).filter((row) =>
+    typeof row.sourceFile === 'string'
+    && moduleFile(row.sourceFile) === modulePath);
+}
+
+function resolveRows(
+  rows: Array<Record<string, unknown>>,
+  repoId: number,
+  modulePath: string,
+): PackageEventConstantResolution {
+  const fields = {
+    targetRepoId: repoId,
+    modulePath,
+    candidateCount: rows.length,
+    complete: true,
+  };
+  if (rows.length !== 1 || !rows[0]) return failure(
+    'event_name_constant_container_ambiguous',
+    fields,
+  );
+  const row = rows[0];
+  if (Number(row.exported) !== 1) return failure(
+    'event_name_constant_container_not_exported', fields,
+  );
+  if (Number(row.stable) !== 1) return failure(
+    'event_name_constant_container_mutable', fields,
+  );
+  if (row.resolutionStatus !== 'resolved'
+    || typeof row.value !== 'string') return failure(
+    String(row.unresolvedReason) === 'event_name_constant_container_mutable'
+      ? 'event_name_constant_container_mutable'
+      : 'event_name_constant_member_not_string',
+    fields,
+  );
+  return {
+    ...fields,
+    status: 'resolved',
+    value: row.value,
+    sourceFile: String(row.sourceFile),
+    sourceLine: Number(row.sourceLine),
+    eligibleCandidateCount: 1,
+  };
+}
+
+function resolveCall(
+  db: Db,
+  workspaceId: number,
+  call: EventConstantCall,
+): PackageEventConstantResolution {
+  const packageName = call.binding.requestedPackageName ?? '';
+  const matches = repositories(db, workspaceId, packageName);
+  if (matches.length !== 1 || !matches[0]) return failure(
+    'event_name_constant_container_ambiguous',
+    { candidateCount: matches.length, complete: matches.length === 0 },
+  );
+  const module = entryModule(matches[0], call.binding);
+  if (typeof module !== 'string') return {
+    ...module, targetRepoId: matches[0].id,
+  };
+  return resolveRows(
+    constantRows(
+      db, matches[0].id, module, call.binding.requestedPublicName,
+    ),
+    matches[0].id,
+    module,
+  );
+}
+
+export function expectedPackageEventConstantResolution(
+  db: Db,
+  workspaceId: number,
+  binding: SymbolImportReference,
+): PackageEventConstantResolution {
+  return resolveCall(db, workspaceId, {
+    id: 0,
+    binding,
+    evidence: {},
+  });
+}
+
+function receiverReason(call: EventConstantCall): string | null {
+  return call.evidence.receiverClassification === 'unproven'
+    ? call.unresolvedReason ?? 'event_receiver_unproven_binding' : null;
+}
+
+function resolutionEvidence(
+  call: EventConstantCall,
+  resolution: PackageEventConstantResolution,
+): string {
+  const evidence = { ...call.evidence };
+  delete evidence.eventNameUnresolvedReason;
+  delete evidence.eventNameStatus;
+  delete evidence.eventNameSourceKind;
+  delete evidence.eventNamePlaceholderKeys;
+  if (resolution.status !== 'resolved')
+    evidence.eventNameUnresolvedReason = resolution.reason;
+  return JSON.stringify({
+    ...evidence,
+    ...(resolution.status === 'resolved' ? {
+      eventNameConstant: {
+        sourceKind: 'package_static_string',
+        sourceFile: resolution.sourceFile,
+        sourceLine: resolution.sourceLine,
+      },
+    } : {}),
+    eventNamePackageConstantResolution: {
+      status: resolution.status,
+      reason: resolution.reason,
+      candidateCount: resolution.candidateCount,
+      eligibleCandidateCount: resolution.eligibleCandidateCount,
+      selectedCandidateCount: resolution.status === 'resolved' ? 1 : 0,
+      candidateSetComplete: resolution.complete,
+      requestedPackageName: call.binding.requestedPackageName,
+      requestedModuleSubpath: call.binding.requestedModuleSubpath,
+      requestedPublicName: call.binding.requestedPublicName,
+      resolvedModulePath: resolution.modulePath,
+      targetRepositoryId: resolution.targetRepoId,
+    },
+  });
+}
+
+export function linkPackageEventConstants(
+  db: Db,
+  workspaceId: number,
+): PackageEventConstantLinkSummary {
+  const summary = { resolved: 0, ambiguous: 0, unresolved: 0 };
+  const update = db.prepare(`UPDATE outbound_calls SET event_name_expr=?,
+    unresolved_reason=?,evidence_json=? WHERE id=?`);
+  for (const call of callRows(db, workspaceId)) {
+    const resolution = resolveCall(db, workspaceId, call);
+    const reason = receiverReason(call) ?? resolution.reason ?? null;
+    const sourceExpression = call.evidence.eventNameConstantSourceExpression;
+    update.run(
+      resolution.value ?? String(sourceExpression ?? ''),
+      reason,
+      resolutionEvidence(call, resolution),
+      call.id,
+    );
+    summary[resolution.status] += 1;
+  }
+  return summary;
+}

package/src/linker/{003-package-import-symbol-resolver.ts → package-import-symbol-resolver.ts}

@@ -3,14 +3,14 @@ import type {
   PackagePublicScope,
   PackagePublicSurfaceFact,
   PublicSurfaceTarget,
-} from '../parsers/003-package-public-surface.js';
+} from '../parsers/package-public-surface.js';
 import type {
   SymbolImportReference,
-} from '../parsers/002-symbol-import-bindings.js';
+} from '../parsers/symbol-import-bindings.js';
 import {
   parsePackageImportReference,
   parsePackagePublicSurfaceFact,
-} from '../parsers/012-package-fact-contract.js';
+} from '../parsers/package-fact-contract.js';
 
 export interface PackageSymbolLinkSummary {
   resolved: number;

package/src/linker/service-resolver.ts

@@ -1,6 +1,6 @@
 import type { Db } from '../db/connection.js';
-import { extractPlaceholderKeys } from '../utils/001-placeholders.js';
-import { canonicalImplementationEvidence } from './000-implementation-candidates.js';
+import { extractPlaceholderKeys } from '../utils/placeholders.js';
+import { canonicalImplementationEvidence } from './implementation-candidates.js';
 export interface OperationTarget {
   operationId: number;
   repoName: string;

package/src/output/{001-compact-json-output.ts → compact-json-output.ts}

@@ -1,4 +1,4 @@
-import type { CompactGraphV1 } from '../trace/014-compact-contract.js';
+import type { CompactGraphV1 } from '../trace/compact-contract.js';
 import { redactValue } from '../utils/redaction.js';
 
 export function renderCompactJson(value: CompactGraphV1): string {

package/src/output/table-output.ts

@@ -23,7 +23,7 @@ function location(evidence: Record<string, unknown>): string {
 export function renderTraceTable(result: TraceResult): string {
   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}`));
   }
@@ -31,6 +31,18 @@ export function renderTraceTable(result: TraceResult): string {
   return `${lines.join('\n')}\n`;
 }
 
+function evidenceSummary(evidence: Record<string, unknown>): string {
+  const labels = [
+    typeof evidence.dispatchScope === 'string'
+      ? `scope=${evidence.dispatchScope}` : undefined,
+    typeof evidence.dispatchCertainty === 'string'
+      ? `certainty=${evidence.dispatchCertainty}` : undefined,
+  ].filter((value): value is string => Boolean(value));
+  return labels.length > 0
+    ? `${location(evidence)} [${labels.join(',')}]`
+    : location(evidence);
+}
+
 function diagnosticLines(diagnostic: Record<string, unknown>): string[] {
   const first = `${String(diagnostic.severity ?? 'info')} ${String(diagnostic.code ?? 'diagnostic')} ${String(diagnostic.message ?? '')}`;
   const details = diagnosticDetailLines(diagnostic);

package/src/parsers/{006-binding-identity.ts → binding-identity.ts}

@@ -9,7 +9,7 @@ import type {
 import {
   executableSymbolCandidates,
   selectCallOwner,
-} from './004-fact-identity.js';
+} from './fact-identity.js';
 import {
   bindingSite,
   createBindingLexicalIndex,
@@ -17,8 +17,8 @@ import {
   type BindingLexicalIndex,
   type BindingLexicalSite,
   type VisibleBinding,
-} from './011-binding-lexical-scope.js';
-import { selectVisibleBinding } from './021-binding-visibility.js';
+} from './binding-lexical-scope.js';
+import { selectVisibleBinding } from './binding-visibility.js';
 
 const scopeChainCap = 16;
 

package/src/parsers/{011-binding-lexical-scope.ts → binding-lexical-scope.ts}

@@ -3,7 +3,7 @@ import type { LexicalScopeFact } from '../types.js';
 import {
   bindingAssignmentEntries,
   type BindingAssignmentEntry,
-} from './019-binding-assignment-targets.js';
+} from './binding-assignment-targets.js';
 
 export type BindingDeclarationKind =
   | 'const'

package/src/parsers/{021-binding-visibility.ts → binding-visibility.ts}

@@ -10,7 +10,7 @@ import {
   type BindingLexicalSite,
   type BindingSiteCandidate,
   type VisibleBinding,
-} from './011-binding-lexical-scope.js';
+} from './binding-lexical-scope.js';
 
 function reachingSites(
   index: BindingLexicalIndex,

package/src/parsers/decorator-parser.ts

@@ -14,6 +14,10 @@ import {
   type RepositorySourceContext,
 } from './ts-project.js';
 import { normalizePath } from '../utils/path-utils.js';
+import {
+  collectStringConstantLookups,
+  type StringConstantLookups,
+} from './string-constant-lookups.js';
 
 type DecoratorResolution = HandlerMethodFact['decoratorResolution'];
 type ResolvedArgumentKind = Exclude<
@@ -21,9 +25,7 @@ type ResolvedArgumentKind = Exclude<
   'lifecycle_implicit' | 'unresolved'
 >;
 interface StringLookups {
-  identifiers: Map<string, string>;
-  enumMembers: Map<string, string>;
-  objectProperties: Map<string, string>;
+  strings: StringConstantLookups;
   capDecoratorNames: Map<string, string>;
   capDecoratorNamespaces: Set<string>;
 }
@@ -94,60 +96,14 @@ function unwrapExpression(expression: ts.Expression): ts.Expression {
   ) current = current.expression;
   return current;
 }
-function stringValue(expression: ts.Expression | undefined): string | undefined {
-  if (!expression) return undefined;
-  const unwrapped = unwrapExpression(expression);
-  return ts.isStringLiteralLike(unwrapped) ? unwrapped.text : undefined;
-}
-function propertyName(node: ts.PropertyName): string | undefined {
-  if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) return node.text;
-  return undefined;
-}
-function collectEnumMembers(
-  statement: ts.EnumDeclaration,
-  lookups: StringLookups,
-): void {
-  for (const member of statement.members) {
-    const name = propertyName(member.name);
-    const value = stringValue(member.initializer);
-    if (name && value !== undefined)
-      lookups.enumMembers.set(`${statement.name.text}.${name}`, value);
-  }
-}
-function collectObjectProperties(
-  name: string,
-  initializer: ts.Expression,
-  lookups: StringLookups,
-): void {
-  const object = unwrapExpression(initializer);
-  if (!ts.isObjectLiteralExpression(object)) return;
-  for (const property of object.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const key = propertyName(property.name);
-    const value = stringValue(property.initializer);
-    if (key && value !== undefined)
-      lookups.objectProperties.set(`${name}.${key}`, value);
-  }
-}
 function collectStringLookups(source: ts.SourceFile): StringLookups {
   const lookups: StringLookups = {
-    identifiers: new Map(),
-    enumMembers: new Map(),
-    objectProperties: new Map(),
+    strings: collectStringConstantLookups(source),
     capDecoratorNames: new Map(),
     capDecoratorNamespaces: new Set(),
   };
   for (const statement of source.statements) {
     collectCapDecoratorImports(statement, lookups);
-    if (ts.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
-    if (!ts.isVariableStatement(statement)
-      || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
-      const value = stringValue(declaration.initializer);
-      if (value !== undefined) lookups.identifiers.set(declaration.name.text, value);
-      collectObjectProperties(declaration.name.text, declaration.initializer, lookups);
-    }
   }
   return lookups;
 }
@@ -226,7 +182,7 @@ function resolveDecoratorArgument(
   if (ts.isStringLiteralLike(expression))
     return resolved(rawExpression, argumentExpression, expression.text, 'literal');
   if (ts.isIdentifier(expression)) {
-    const value = lookups.identifiers.get(expression.text);
+    const value = lookups.strings.identifiers.get(expression.text)?.value;
     return value === undefined
       ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string', argumentExpression)
       : resolved(rawExpression, argumentExpression, value, 'const_identifier');
@@ -234,10 +190,10 @@ function resolveDecoratorArgument(
   if (ts.isPropertyAccessExpression(expression)
     && ts.isIdentifier(expression.expression)) {
     const key = `${expression.expression.text}.${expression.name.text}`;
-    const enumValue = lookups.enumMembers.get(key);
+    const enumValue = lookups.strings.enumMembers.get(key)?.value;
     if (enumValue !== undefined)
       return resolved(rawExpression, argumentExpression, enumValue, 'enum_member');
-    const objectValue = lookups.objectProperties.get(key);
+    const objectValue = lookups.strings.objectProperties.get(key)?.value;
     if (objectValue !== undefined)
       return resolved(rawExpression, argumentExpression, objectValue, 'const_object_property');
   }