@saptools/service-flow 0.1.51 → 0.1.52

package/src/parsers/decorator-parser.ts

@@ -1,17 +1,65 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import ts from 'typescript';
-import type { HandlerClassFact, HandlerMethodFact } from '../types.js';
+import type {
+  HandlerClassFact,
+  HandlerLifecycleEvent,
+  HandlerLifecyclePhase,
+  HandlerMethodFact,
+  HandlerMethodKind,
+} from '../types.js';
 import { generatedOperationNameFromConstant } from '../linker/operation-decorator-normalizer.js';
-import { createSourceFile } from './ts-project.js';
+import {
+  createSourceFile,
+  type RepositorySourceContext,
+} from './ts-project.js';
 import { normalizePath } from '../utils/path-utils.js';
 
 type DecoratorResolution = HandlerMethodFact['decoratorResolution'];
+type ResolvedArgumentKind = Exclude<
+  DecoratorResolution['resolutionKind'],
+  'lifecycle_implicit' | 'unresolved'
+>;
 interface StringLookups {
   identifiers: Map<string, string>;
   enumMembers: Map<string, string>;
   objectProperties: Map<string, string>;
+  capDecoratorNames: Map<string, string>;
+  capDecoratorNamespaces: Set<string>;
 }
+interface LifecycleMetadata {
+  phase: HandlerLifecyclePhase;
+  event: HandlerLifecycleEvent;
+}
+interface MethodClassification {
+  handlerKind: HandlerMethodKind;
+  executable: boolean;
+  lifecyclePhase?: HandlerLifecyclePhase;
+  lifecycleEvent?: HandlerLifecycleEvent;
+}
+interface ParsedMethodDecorator {
+  classification: MethodClassification;
+  resolution: DecoratorResolution;
+  decoratorKind: string;
+  importedKind?: string;
+}
+
+const OPERATION_DECORATORS = new Set(['Action', 'Func', 'On']);
+const EVENT_DECORATORS = new Set(['Event']);
+const LIFECYCLE_DECORATORS = new Map<string, LifecycleMetadata>([
+  ['BeforeCreate', { phase: 'before', event: 'CREATE' }],
+  ['OnCreate', { phase: 'on', event: 'CREATE' }],
+  ['AfterCreate', { phase: 'after', event: 'CREATE' }],
+  ['BeforeRead', { phase: 'before', event: 'READ' }],
+  ['OnRead', { phase: 'on', event: 'READ' }],
+  ['AfterRead', { phase: 'after', event: 'READ' }],
+  ['BeforeUpdate', { phase: 'before', event: 'UPDATE' }],
+  ['OnUpdate', { phase: 'on', event: 'UPDATE' }],
+  ['AfterUpdate', { phase: 'after', event: 'UPDATE' }],
+  ['BeforeDelete', { phase: 'before', event: 'DELETE' }],
+  ['OnDelete', { phase: 'on', event: 'DELETE' }],
+  ['AfterDelete', { phase: 'after', event: 'DELETE' }],
+]);
 
 function line(sf: ts.SourceFile, pos: number): number {
   return sf.getLineAndCharacterOfPosition(pos).line + 1;
@@ -27,6 +75,15 @@ function firstArg(d: ts.Decorator): ts.Expression | undefined {
   const e = d.expression;
   return ts.isCallExpression(e) ? e.arguments[0] : undefined;
 }
+function decoratorArguments(d: ts.Decorator): readonly ts.Expression[] | undefined {
+  return ts.isCallExpression(d.expression) ? d.expression.arguments : undefined;
+}
+function methodName(name: ts.PropertyName): string {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name)
+    ? name.text
+    : name.getText();
+}
 function unwrapExpression(expression: ts.Expression): ts.Expression {
   let current = expression;
   while (
@@ -77,8 +134,11 @@ function collectStringLookups(source: ts.SourceFile): StringLookups {
     identifiers: new Map(),
     enumMembers: new Map(),
     objectProperties: new Map(),
+    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;
@@ -91,8 +151,62 @@ function collectStringLookups(source: ts.SourceFile): StringLookups {
   }
   return lookups;
 }
-function unresolved(rawExpression: string, reason: string): DecoratorResolution {
-  return { rawExpression, resolutionKind: 'unresolved', unresolvedReason: reason };
+function collectCapDecoratorImports(
+  statement: ts.Statement,
+  lookups: StringLookups,
+): void {
+  if (!ts.isImportDeclaration(statement)
+    || !ts.isStringLiteral(statement.moduleSpecifier)
+    || statement.moduleSpecifier.text !== 'cds-routing-handlers') return;
+  const clause = statement.importClause;
+  if (!clause || clause.isTypeOnly) return;
+  const bindings = clause.namedBindings;
+  if (bindings && ts.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      if (element.isTypeOnly) continue;
+      lookups.capDecoratorNames.set(
+        element.name.text,
+        element.propertyName?.text ?? element.name.text,
+      );
+    }
+  }
+  if (bindings && ts.isNamespaceImport(bindings))
+    lookups.capDecoratorNamespaces.add(bindings.name.text);
+}
+function capDecoratorName(
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+): string | undefined {
+  const expression = ts.isCallExpression(decorator.expression)
+    ? decorator.expression.expression
+    : decorator.expression;
+  if (ts.isIdentifier(expression))
+    return lookups.capDecoratorNames.get(expression.text);
+  if (ts.isPropertyAccessExpression(expression)
+    && ts.isIdentifier(expression.expression)
+    && lookups.capDecoratorNamespaces.has(expression.expression.text))
+    return expression.name.text;
+  return undefined;
+}
+function unresolved(
+  rawExpression: string,
+  reason: string,
+  argumentExpression?: string,
+): DecoratorResolution {
+  return {
+    rawExpression,
+    argumentExpression,
+    resolutionKind: 'unresolved',
+    unresolvedReason: reason,
+  };
+}
+function resolved(
+  rawExpression: string,
+  argumentExpression: string,
+  resolvedValue: string,
+  resolutionKind: ResolvedArgumentKind,
+): DecoratorResolution {
+  return { rawExpression, argumentExpression, resolvedValue, resolutionKind };
 }
 function generatedConstant(rawExpression: string): string | undefined {
   const match = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/
@@ -104,76 +218,296 @@ function generatedConstant(rawExpression: string): string | undefined {
 function resolveDecoratorArgument(
   argument: ts.Expression | undefined,
   lookups: StringLookups,
+  rawExpression: string,
 ): DecoratorResolution {
-  if (!argument) return unresolved('', 'decorator_argument_missing');
-  const rawExpression = argument.getText();
+  if (!argument) return unresolved(rawExpression, 'decorator_argument_missing');
+  const argumentExpression = argument.getText();
   const expression = unwrapExpression(argument);
   if (ts.isStringLiteralLike(expression))
-    return { rawExpression, resolvedValue: expression.text, resolutionKind: 'literal' };
+    return resolved(rawExpression, argumentExpression, expression.text, 'literal');
   if (ts.isIdentifier(expression)) {
     const value = lookups.identifiers.get(expression.text);
     return value === undefined
-      ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string')
-      : { rawExpression, resolvedValue: value, resolutionKind: 'const_identifier' };
+      ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string', argumentExpression)
+      : resolved(rawExpression, argumentExpression, value, 'const_identifier');
   }
   if (ts.isPropertyAccessExpression(expression)
     && ts.isIdentifier(expression.expression)) {
     const key = `${expression.expression.text}.${expression.name.text}`;
     const enumValue = lookups.enumMembers.get(key);
     if (enumValue !== undefined)
-      return { rawExpression, resolvedValue: enumValue, resolutionKind: 'enum_member' };
+      return resolved(rawExpression, argumentExpression, enumValue, 'enum_member');
     const objectValue = lookups.objectProperties.get(key);
     if (objectValue !== undefined)
-      return { rawExpression, resolvedValue: objectValue, resolutionKind: 'const_object_property' };
+      return resolved(rawExpression, argumentExpression, objectValue, 'const_object_property');
   }
-  const generatedValue = generatedConstant(rawExpression);
+  const generatedValue = generatedConstant(argumentExpression);
   if (generatedValue !== undefined)
-    return {
+    return resolved(
       rawExpression,
-      resolvedValue: generatedValue,
-      resolutionKind: 'generated_constant_name',
-    };
+      argumentExpression,
+      generatedValue,
+      'generated_constant_name',
+    );
   if (ts.isPropertyAccessExpression(expression))
-    return unresolved(rawExpression, 'property_access_not_resolved_to_local_string');
-  return unresolved(rawExpression, 'unsupported_decorator_expression');
+    return unresolved(
+      rawExpression,
+      'property_access_not_resolved_to_local_string',
+      argumentExpression,
+    );
+  return unresolved(rawExpression, 'unsupported_decorator_expression', argumentExpression);
+}
+function classificationFor(name: string): MethodClassification | undefined {
+  if (OPERATION_DECORATORS.has(name))
+    return { handlerKind: 'operation', executable: true };
+  if (EVENT_DECORATORS.has(name))
+    return { handlerKind: 'event', executable: true };
+  const lifecycle = LIFECYCLE_DECORATORS.get(name);
+  if (!lifecycle) return undefined;
+  return {
+    handlerKind: 'entity_lifecycle',
+    executable: true,
+    lifecyclePhase: lifecycle.phase,
+    lifecycleEvent: lifecycle.event,
+  };
+}
+function lifecycleLikePhase(name: string): HandlerLifecyclePhase | undefined {
+  if (/^On[A-Z]/.test(name)) return 'on';
+  if (/^Before[A-Z]/.test(name)) return 'before';
+  if (/^After[A-Z]/.test(name)) return 'after';
+  return undefined;
+}
+function withClassification(
+  resolution: DecoratorResolution,
+  classification: MethodClassification,
+): DecoratorResolution {
+  return {
+    ...resolution,
+    handlerKind: classification.handlerKind,
+    executable: classification.executable,
+    lifecyclePhase: classification.lifecyclePhase,
+    lifecycleEvent: classification.lifecycleEvent,
+  };
+}
+function withDecoratorEvidence(
+  resolution: DecoratorResolution,
+  decorator: ts.Decorator,
+  resolvedDecoratorKind: string | undefined,
+): DecoratorResolution {
+  return {
+    ...resolution,
+    decoratorExpression: decorator.expression.getText(),
+    resolvedDecoratorKind,
+    decoratorImportSource: resolvedDecoratorKind
+      ? 'cds-routing-handlers'
+      : undefined,
+  };
+}
+function lifecycleDecoratorResolution(
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+  classification: MethodClassification,
+): { classification: MethodClassification; resolution: DecoratorResolution } {
+  const rawExpression = decorator.expression.getText();
+  const args = decoratorArguments(decorator);
+  if (args?.length === 0)
+    return {
+      classification,
+      resolution: withClassification({
+        rawExpression,
+        resolutionKind: 'lifecycle_implicit',
+      }, classification),
+    };
+  const resolution = args?.length === 1
+    ? resolveDecoratorArgument(args[0], lookups, rawExpression)
+    : unresolved(rawExpression, args ? 'unsupported_lifecycle_argument_count' : 'lifecycle_decorator_call_required');
+  const unsupported = { ...classification, handlerKind: 'unsupported_lifecycle', executable: false } as const;
+  const unsupportedResolution = args?.length === 1
+    ? { ...resolution, unresolvedReason: 'lifecycle_decorator_arguments_not_supported' }
+    : resolution;
+  return {
+    classification: unsupported,
+    resolution: withClassification(unsupportedResolution, unsupported),
+  };
+}
+function unsupportedLifecycleResolution(
+  decorator: ts.Decorator,
+  phase: HandlerLifecyclePhase,
+): { classification: MethodClassification; resolution: DecoratorResolution } {
+  const classification: MethodClassification = {
+    handlerKind: 'unsupported_lifecycle',
+    executable: false,
+    lifecyclePhase: phase,
+  };
+  const resolution = unresolved(
+    decorator.expression.getText(),
+    'lifecycle_decorator_not_allowlisted',
+  );
+  return { classification, resolution: withClassification(resolution, classification) };
+}
+function unsupportedDecoratorResolution(
+  decorator: ts.Decorator,
+  reason: string,
+  phase?: HandlerLifecyclePhase,
+): { classification: MethodClassification; resolution: DecoratorResolution } {
+  const classification: MethodClassification = {
+    handlerKind: phase ? 'unsupported_lifecycle' : 'unsupported_decorator',
+    executable: false,
+    lifecyclePhase: phase,
+  };
+  return {
+    classification,
+    resolution: withClassification(
+      unresolved(decorator.expression.getText(), reason),
+      classification,
+    ),
+  };
+}
+function parseMethodDecorator(
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+  handlerClass: boolean,
+  allowLifecycle: boolean,
+): ParsedMethodDecorator | undefined {
+  const decoratorKind = callName(decorator);
+  const importedKind = capDecoratorName(decorator, lookups);
+  const resolvedKind = importedKind ?? decoratorKind;
+  const base = classificationFor(resolvedKind);
+  const phase = lifecycleLikePhase(resolvedKind);
+  const isLifecycle = base?.handlerKind === 'entity_lifecycle' || Boolean(phase && !base);
+  if (!handlerClass && isLifecycle) return undefined;
+  const parsed = isLifecycle && (!allowLifecycle || !importedKind)
+    ? unsupportedDecoratorResolution(
+        decorator, 'lifecycle_decorator_import_not_supported', phase,
+      )
+    : base?.handlerKind === 'entity_lifecycle'
+      ? lifecycleDecoratorResolution(decorator, lookups, base)
+      : phase && !base
+        ? unsupportedLifecycleResolution(decorator, phase)
+        : !base && handlerClass
+          ? unsupportedDecoratorResolution(decorator, 'decorator_not_allowlisted')
+          : {
+              classification: base,
+              resolution: resolveDecoratorArgument(
+                firstArg(decorator),
+                lookups,
+                firstArg(decorator)?.getText() ?? decorator.expression.getText(),
+              ),
+            };
+  if (!parsed.classification) return undefined;
+  return {
+    classification: parsed.classification,
+    resolution: parsed.resolution,
+    decoratorKind,
+    importedKind,
+  };
+}
+function methodDecoratorFact(
+  method: ts.MethodDeclaration,
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+  source: ts.SourceFile,
+  filePath: string,
+  handlerClass: boolean,
+  allowLifecycle: boolean,
+): HandlerMethodFact | undefined {
+  const parsed = parseMethodDecorator(decorator, lookups, handlerClass, allowLifecycle);
+  if (!parsed) return undefined;
+  const classification = method.body
+    ? parsed.classification
+    : { ...parsed.classification, executable: false };
+  const resolution = method.body
+    ? parsed.resolution
+    : { ...parsed.resolution, unresolvedReason: 'handler_method_body_missing' };
+  const argumentExpression = firstArg(decorator)?.getText();
+  return {
+    methodName: methodName(method.name),
+    decoratorKind: parsed.decoratorKind,
+    decoratorValue: parsed.resolution.resolvedValue,
+    decoratorRawExpression: argumentExpression ?? decorator.expression.getText(),
+    handlerKind: classification.handlerKind,
+    executable: classification.executable,
+    lifecyclePhase: classification.lifecyclePhase,
+    lifecycleEvent: classification.lifecycleEvent,
+    decoratorResolution: withDecoratorEvidence(
+      withClassification(resolution, classification),
+      decorator,
+      parsed.importedKind,
+    ),
+    sourceFile: normalizePath(filePath),
+    sourceLine: line(source, method.getStart()),
+  };
+}
+function unique(values: string[]): string[] {
+  return [...new Set(values)];
+}
+function parseClassMethods(
+  node: ts.ClassDeclaration,
+  lookups: StringLookups,
+  source: ts.SourceFile,
+  filePath: string,
+  handlerClass: boolean,
+  allowLifecycle: boolean,
+): Pick<HandlerClassFact, 'methods' | 'observedDecoratorNames' | 'unsupportedDecoratorNames'> {
+  const methods: HandlerMethodFact[] = [];
+  const observed: string[] = [];
+  const unsupported: string[] = [];
+  for (const method of node.members.filter(ts.isMethodDeclaration)) {
+    for (const decorator of decs(method)) {
+      observed.push(callName(decorator));
+      const fact = methodDecoratorFact(
+        method, decorator, lookups, source, filePath, handlerClass, allowLifecycle,
+      );
+      if (fact) methods.push(fact);
+      if (!fact?.executable) unsupported.push(callName(decorator));
+    }
+  }
+  return {
+    methods,
+    observedDecoratorNames: unique(observed),
+    unsupportedDecoratorNames: unique(unsupported),
+  };
+}
+function parseHandlerClass(
+  node: ts.ClassDeclaration,
+  lookups: StringLookups,
+  source: ts.SourceFile,
+  filePath: string,
+): HandlerClassFact | undefined {
+  const classDecoratorNames = unique(decs(node).map(callName));
+  const classDecorators = decs(node);
+  const hasImportedHandler = classDecorators.some((decorator) =>
+    capDecoratorName(decorator, lookups) === 'Handler');
+  const hasHandlerDecorator = hasImportedHandler
+    || classDecoratorNames.includes('Handler');
+  const parsed = parseClassMethods(
+    node, lookups, source, filePath, hasHandlerDecorator, hasImportedHandler,
+  );
+  if (!hasHandlerDecorator && parsed.methods.length === 0) return undefined;
+  return {
+    className: node.name?.text ?? 'AnonymousHandler',
+    sourceFile: normalizePath(filePath),
+    sourceLine: line(source, node.getStart()),
+    ...parsed,
+    hasHandlerDecorator,
+    classDecoratorNames,
+  };
 }
 export async function parseDecorators(
   repoPath: string,
-  filePath: string
+  filePath: string,
+  context?: RepositorySourceContext,
 ): Promise<HandlerClassFact[]> {
-  const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
-  const sf = createSourceFile(filePath, text);
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text
+    ?? await fs.readFile(path.join(repoPath, filePath), 'utf8');
+  const sf = snapshot?.sourceFile() ?? createSourceFile(filePath, text);
   const lookups = collectStringLookups(sf);
   const handlers: HandlerClassFact[] = [];
   function visit(node: ts.Node): void {
     if (ts.isClassDeclaration(node)) {
-      const className = node.name?.text ?? 'AnonymousHandler';
-      const hasHandler = decs(node).some((d) => callName(d) === 'Handler');
-      const methods = node.members.filter(ts.isMethodDeclaration).flatMap((m) =>
-        decs(m)
-          .filter((d) =>
-            ['Func', 'Action', 'On', 'Event'].includes(callName(d))
-          )
-          .map((d) => {
-            const decoratorResolution = resolveDecoratorArgument(firstArg(d), lookups);
-            return {
-              methodName: m.name.getText(),
-              decoratorKind: callName(d),
-              decoratorValue: decoratorResolution.resolvedValue,
-              decoratorRawExpression: decoratorResolution.rawExpression,
-              decoratorResolution,
-              sourceFile: normalizePath(filePath),
-              sourceLine: line(sf, m.getStart())
-            };
-          })
-      );
-      if (hasHandler || methods.length > 0)
-        handlers.push({
-          className,
-          sourceFile: normalizePath(filePath),
-          sourceLine: line(sf, node.getStart()),
-          methods
-        });
+      const handler = parseHandlerClass(node, lookups, sf, filePath);
+      if (handler) handlers.push(handler);
     }
     ts.forEachChild(node, visit);
   }

package/src/parsers/handler-registration-parser.ts

@@ -4,6 +4,7 @@ import path from 'node:path';
 import ts from 'typescript';
 import type { HandlerRegistrationFact } from '../types.js';
 import { normalizePath } from '../utils/path-utils.js';
+import type { RepositorySourceContext } from './ts-project.js';
 
 interface ImportEvidence { importedName: string; source: string }
 interface ClassEvidence { className: string; importSource?: string }
@@ -26,16 +27,26 @@ function importSourceFor(identifier: string, imports: Map<string, ImportEvidence
   return evidence ? `${evidence.source}#${evidence.importedName}` : undefined;
 }
 
-export async function parseHandlerRegistrations(repoPath: string, filePath: string): Promise<HandlerRegistrationFact[]> {
+export async function parseHandlerRegistrations(
+  repoPath: string,
+  filePath: string,
+  context?: RepositorySourceContext,
+): Promise<HandlerRegistrationFact[]> {
   const absolutePath = path.join(repoPath, filePath);
-  const text = await fs.readFile(absolutePath, 'utf8');
-  const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text ?? await fs.readFile(absolutePath, 'utf8');
+  const sourceFile = snapshot?.sourceFile() ?? ts.createSourceFile(
+    filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS,
+  );
   const imports = collectImports(sourceFile);
-  const localArrays = collectLocalArrays(sourceFile, imports, new Map(), repoPath, filePath);
+  const localArrays = collectLocalArrays(
+    sourceFile, imports, new Map(), repoPath, filePath, context,
+  );
   const out: HandlerRegistrationFact[] = [];
-
   function emitFromExpression(expression: ts.Expression, call: ts.CallExpression): void {
-    const classes = resolveArrayExpression(expression, localArrays, imports, repoPath, filePath, new Set());
+    const classes = resolveArrayExpression(
+      expression, localArrays, imports, repoPath, filePath, new Set(), context,
+    );
     for (const cls of classes) {
       out.push({
         className: cls.className,
@@ -55,7 +66,6 @@ export async function parseHandlerRegistrations(repoPath: string, filePath: stri
       });
     }
   }
-
   function visit(node: ts.Node): void {
     if (ts.isCallExpression(node) && isRegistrationCall(node)) {
       const handlerExpr = handlerExpression(node, sourceFile);
@@ -98,45 +108,47 @@ function collectImports(sourceFile: ts.SourceFile): Map<string, ImportEvidence>
   }
   return imports;
 }
-function collectLocalArrays(sourceFile: ts.SourceFile, imports: Map<string, ImportEvidence>, seed: Map<string, ClassEvidence[]>, repoPath = '', fromFile = ''): Map<string, ClassEvidence[]> {
+function collectLocalArrays(sourceFile: ts.SourceFile, imports: Map<string, ImportEvidence>, seed: Map<string, ClassEvidence[]>, repoPath = '', fromFile = '', context?: RepositorySourceContext): Map<string, ClassEvidence[]> {
   const arrays = new Map(seed);
   for (const statement of sourceFile.statements) {
     if (ts.isVariableStatement(statement)) {
       for (const decl of statement.declarationList.declarations) {
         if (ts.isIdentifier(decl.name) && decl.initializer && ts.isArrayLiteralExpression(decl.initializer)) {
-          arrays.set(decl.name.text, resolveArrayLiteral(decl.initializer, arrays, imports, repoPath, fromFile, new Set()));
+          arrays.set(decl.name.text, resolveArrayLiteral(
+            decl.initializer, arrays, imports, repoPath, fromFile, new Set(), context,
+          ));
         }
       }
     }
   }
   return arrays;
 }
-function resolveArrayExpression(expr: ts.Expression, arrays: Map<string, ClassEvidence[]>, imports: Map<string, ImportEvidence>, repoPath: string, fromFile: string, seen: Set<string>): ClassEvidence[] {
-  if (ts.isArrayLiteralExpression(expr)) return resolveArrayLiteral(expr, arrays, imports, repoPath, fromFile, seen);
+function resolveArrayExpression(expr: ts.Expression, arrays: Map<string, ClassEvidence[]>, imports: Map<string, ImportEvidence>, repoPath: string, fromFile: string, seen: Set<string>, context?: RepositorySourceContext): ClassEvidence[] {
+  if (ts.isArrayLiteralExpression(expr)) return resolveArrayLiteral(expr, arrays, imports, repoPath, fromFile, seen, context);
   if (ts.isIdentifier(expr)) {
     const local = arrays.get(expr.text);
     if (local) return local;
     const evidence = imports.get(expr.text);
-    if (evidence && isRelative(evidence.source)) return resolveImportedArray(repoPath, fromFile, evidence, seen);
+    if (evidence && isRelative(evidence.source)) return resolveImportedArray(repoPath, fromFile, evidence, seen, context);
     if (evidence) return [{ className: evidence.importedName === 'default' ? expr.text : evidence.importedName, importSource: `${evidence.source}#${evidence.importedName}` }];
   }
   return [];
 }
-function resolveArrayLiteral(array: ts.ArrayLiteralExpression, arrays: Map<string, ClassEvidence[]>, imports: Map<string, ImportEvidence>, repoPath: string, fromFile: string, seen: Set<string>): ClassEvidence[] {
+function resolveArrayLiteral(array: ts.ArrayLiteralExpression, arrays: Map<string, ClassEvidence[]>, imports: Map<string, ImportEvidence>, repoPath: string, fromFile: string, seen: Set<string>, context?: RepositorySourceContext): ClassEvidence[] {
   const out: ClassEvidence[] = [];
   for (const element of array.elements) {
-    if (ts.isSpreadElement(element)) out.push(...resolveArrayExpression(element.expression, arrays, imports, repoPath, fromFile, seen));
+    if (ts.isSpreadElement(element)) out.push(...resolveArrayExpression(element.expression, arrays, imports, repoPath, fromFile, seen, context));
     else if (ts.isIdentifier(element)) out.push({ className: element.text, importSource: importSourceFor(element.text, imports) });
   }
   return out;
 }
-function resolveImportedArray(repoPath: string, fromFile: string, evidence: ImportEvidence, seen: Set<string>): ClassEvidence[] {
+function resolveImportedArray(repoPath: string, fromFile: string, evidence: ImportEvidence, seen: Set<string>, context?: RepositorySourceContext): ClassEvidence[] {
   const moduleFile = resolveRelativeModule(repoPath, fromFile, evidence.source);
   if (!moduleFile) return [];
   const key = `${moduleFile}:${evidence.importedName}`;
   if (seen.has(key) || seen.size > MAX_EXPORT_DEPTH) return [];
   seen.add(key);
-  const exports = readExports(repoPath, moduleFile, seen);
+  const exports = readExports(repoPath, moduleFile, seen, context);
   if (evidence.importedName === 'default') return exports.defaultArray ?? [];
   return exports.arrays.get(evidence.importedName) ?? exports.arrays.get(exports.aliases.get(evidence.importedName) ?? evidence.importedName) ?? [];
 }
@@ -150,13 +162,16 @@ function resolveRelativeModule(repoPath: string, fromFile: string, specifier: st
   }
   return undefined;
 }
-function readExports(repoPath: string, filePath: string, seen: Set<string>): FileExports {
+function readExports(repoPath: string, filePath: string, seen: Set<string>, context?: RepositorySourceContext): FileExports {
   const absolute = path.join(repoPath, filePath);
   let text: string;
-  try { text = fsSync.readFileSync(absolute, 'utf8'); } catch { return { arrays: new Map(), aliases: new Map() }; }
-  const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const snapshot = context?.get(filePath);
+  try { text = snapshot?.text ?? fsSync.readFileSync(absolute, 'utf8'); } catch { return { arrays: new Map(), aliases: new Map() }; }
+  const sourceFile = snapshot?.sourceFile() ?? ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
   const imports = collectImports(sourceFile);
-  const arrays = collectLocalArrays(sourceFile, imports, new Map(), repoPath, filePath);
+  const arrays = collectLocalArrays(
+    sourceFile, imports, new Map(), repoPath, filePath, context,
+  );
   const aliases = new Map<string, string>();
   let defaultArray: ClassEvidence[] | undefined;
   for (const statement of sourceFile.statements) {
@@ -167,7 +182,9 @@ function readExports(repoPath: string, filePath: string, seen: Set<string>): Fil
         const local = element.propertyName?.text ?? element.name.text;
         aliases.set(element.name.text, local);
         if (module && isRelative(module)) {
-          const imported = resolveImportedArray(repoPath, filePath, { source: module, importedName: local }, seen);
+          const imported = resolveImportedArray(
+            repoPath, filePath, { source: module, importedName: local }, seen, context,
+          );
           if (imported.length > 0) arrays.set(element.name.text, imported);
         }
       }