@auto-engineer/narrative 0.11.11

package/src/fluent-builder.ts

@@ -0,0 +1,382 @@
+import type { Integration } from './types';
+import {
+  addSlice,
+  startClientBlock,
+  endClientBlock,
+  startServerBlock,
+  endServerBlock,
+  getCurrentSlice,
+} from './narrative-context';
+import { CommandSlice, QuerySlice, ReactSlice, ExperienceSlice } from './index';
+import { print, ASTNode } from 'graphql';
+import createDebug from 'debug';
+
+const debug = createDebug('auto:narrative:fluent-builder');
+if ('color' in debug && typeof debug === 'object') {
+  (debug as { color: string }).color = '6';
+} // cyan
+const debugCommand = createDebug('auto:narrative:fluent-builder:command');
+if ('color' in debugCommand && typeof debugCommand === 'object') {
+  (debugCommand as { color: string }).color = '4';
+} // blue
+const debugQuery = createDebug('auto:narrative:fluent-builder:query');
+if ('color' in debugQuery && typeof debugQuery === 'object') {
+  (debugQuery as { color: string }).color = '4';
+} // blue
+const debugReact = createDebug('auto:narrative:fluent-builder:react');
+if ('color' in debugReact && typeof debugReact === 'object') {
+  (debugReact as { color: string }).color = '2';
+} // green
+const debugExperience = createDebug('auto:narrative:fluent-builder:experience');
+if ('color' in debugExperience && typeof debugExperience === 'object') {
+  (debugExperience as { color: string }).color = '5';
+} // magenta
+
+export interface FluentCommandSliceBuilder {
+  stream(name: string): FluentCommandSliceBuilder;
+  client(fn: () => void): FluentCommandSliceBuilder;
+  client(description: string, fn: () => void): FluentCommandSliceBuilder;
+  server(fn: () => void): FluentCommandSliceBuilder;
+  server(description: string, fn: () => void): FluentCommandSliceBuilder;
+  via(integration: Integration | Integration[]): FluentCommandSliceBuilder;
+  retries(count: number): FluentCommandSliceBuilder;
+  request(mutation: unknown): FluentCommandSliceBuilder;
+}
+
+export interface FluentQuerySliceBuilder {
+  client(fn: () => void): FluentQuerySliceBuilder;
+  client(description: string, fn: () => void): FluentQuerySliceBuilder;
+  server(fn: () => void): FluentQuerySliceBuilder;
+  server(description: string, fn: () => void): FluentQuerySliceBuilder;
+  request(query: unknown): FluentQuerySliceBuilder;
+}
+
+export interface FluentReactionSliceBuilder {
+  server(fn: () => void): FluentReactionSliceBuilder;
+  server(description: string, fn: () => void): FluentReactionSliceBuilder;
+  via(integration: Integration | Integration[]): FluentReactionSliceBuilder;
+  retries(count: number): FluentReactionSliceBuilder;
+}
+
+export interface FluentExperienceSliceBuilder {
+  client(fn: () => void): FluentExperienceSliceBuilder;
+  client(description: string, fn: () => void): FluentExperienceSliceBuilder;
+}
+
+class CommandSliceBuilderImpl implements FluentCommandSliceBuilder {
+  private slice: CommandSlice;
+
+  constructor(name: string, id?: string) {
+    debugCommand('Creating command slice: %s', name);
+    this.slice = {
+      type: 'command',
+      name,
+      id,
+      client: { description: '', specs: undefined },
+      server: { description: '', specs: { name: '', rules: [] }, data: undefined },
+    };
+    addSlice(this.slice);
+    debugCommand('Command slice added to flow: %s', name);
+  }
+
+  stream(name: string): FluentCommandSliceBuilder {
+    debugCommand('Setting stream for slice %s: %s', this.slice.name, name);
+    this.slice.stream = name;
+    return this;
+  }
+
+  client(fn: () => void): FluentCommandSliceBuilder;
+  client(description: string, fn: () => void): FluentCommandSliceBuilder;
+  client(descriptionOrFn: string | (() => void), fn?: () => void): FluentCommandSliceBuilder {
+    const description = typeof descriptionOrFn === 'string' ? descriptionOrFn : '';
+    const callback = typeof descriptionOrFn === 'function' ? descriptionOrFn : fn;
+
+    debugCommand('Adding client block to slice %s, description: "%s"', this.slice.name, description);
+
+    if (callback) {
+      const slice = getCurrentSlice();
+      if (slice) {
+        debugCommand('Starting client block execution');
+        startClientBlock(slice, description);
+        callback();
+        endClientBlock();
+        debugCommand('Client block execution completed');
+      } else {
+        debugCommand('WARNING: No current slice found for client block');
+      }
+    }
+
+    return this;
+  }
+
+  server(fn: () => void): FluentCommandSliceBuilder;
+  server(description: string, fn: () => void): FluentCommandSliceBuilder;
+  server(descriptionOrFn: string | (() => void), fn?: () => void): FluentCommandSliceBuilder {
+    const description = typeof descriptionOrFn === 'string' ? descriptionOrFn : '';
+    const callback = typeof descriptionOrFn === 'function' ? descriptionOrFn : fn;
+
+    debugCommand('Adding server block to slice %s, description: "%s"', this.slice.name, description);
+
+    if (callback) {
+      const slice = getCurrentSlice();
+      if (slice) {
+        debugCommand('Starting server block execution');
+        startServerBlock(slice, description);
+        callback();
+        endServerBlock();
+        debugCommand('Server block execution completed');
+      } else {
+        debugCommand('WARNING: No current slice found for server block');
+      }
+    }
+
+    return this;
+  }
+
+  via(integration: Integration | Integration[]): FluentCommandSliceBuilder {
+    const integrations = Array.isArray(integration) ? integration : [integration];
+    this.slice.via = integrations.map((i) => i.name);
+    debugCommand('Set integrations for slice %s: %o', this.slice.name, this.slice.via);
+    return this;
+  }
+
+  retries(count: number): FluentCommandSliceBuilder {
+    debugCommand('Setting retries for slice %s: %d', this.slice.name, count);
+    // Store retries in additionalInstructions or metadata
+    this.slice.additionalInstructions = `retries: ${count}`;
+    return this;
+  }
+
+  request(query: unknown): FluentCommandSliceBuilder {
+    debugCommand('Setting request for slice %s', this.slice.name);
+    if (typeof query === 'string') {
+      debugCommand('Request is string, length: %d', query.length);
+      this.slice.request = query;
+    } else if (
+      query !== null &&
+      query !== undefined &&
+      typeof query === 'object' &&
+      'kind' in query &&
+      query.kind === 'Document'
+    ) {
+      debugCommand('Request is GraphQL AST Document, converting to SDL');
+      this.slice.request = print(query as ASTNode); // ✅ convert AST to SDL string
+      debugCommand('Converted SDL length: %d', this.slice.request.length);
+    } else {
+      debugCommand('ERROR: Invalid GraphQL query format');
+      throw new Error('Invalid GraphQL query format');
+    }
+    return this;
+  }
+}
+
+class QuerySliceBuilderImpl implements FluentQuerySliceBuilder {
+  private slice: QuerySlice;
+
+  constructor(name: string, id?: string) {
+    debugQuery('Creating query slice: %s', name);
+    this.slice = {
+      type: 'query',
+      name,
+      id,
+      client: { description: '', specs: undefined },
+      server: { description: '', specs: { name: '', rules: [] }, data: undefined },
+    };
+    addSlice(this.slice);
+    debugQuery('Query slice added to flow: %s', name);
+  }
+
+  client(fn: () => void): FluentQuerySliceBuilder;
+  client(description: string, fn: () => void): FluentQuerySliceBuilder;
+  client(descriptionOrFn: string | (() => void), fn?: () => void): FluentQuerySliceBuilder {
+    const description = typeof descriptionOrFn === 'string' ? descriptionOrFn : '';
+    const callback = typeof descriptionOrFn === 'function' ? descriptionOrFn : fn;
+
+    debugQuery('Adding client block to slice %s, description: "%s"', this.slice.name, description);
+
+    if (callback) {
+      const slice = getCurrentSlice();
+      if (slice) {
+        debugQuery('Starting client block execution');
+        startClientBlock(slice, description);
+        callback();
+        endClientBlock();
+        debugQuery('Client block execution completed');
+      } else {
+        debugQuery('WARNING: No current slice found for client block');
+      }
+    }
+
+    return this;
+  }
+
+  server(fn: () => void): FluentQuerySliceBuilder;
+  server(description: string, fn: () => void): FluentQuerySliceBuilder;
+  server(descriptionOrFn: string | (() => void), fn?: () => void): FluentQuerySliceBuilder {
+    const description = typeof descriptionOrFn === 'string' ? descriptionOrFn : '';
+    const callback = typeof descriptionOrFn === 'function' ? descriptionOrFn : fn;
+
+    debugQuery('Adding server block to slice %s, description: "%s"', this.slice.name, description);
+
+    if (callback) {
+      const slice = getCurrentSlice();
+      if (slice) {
+        debugQuery('Starting server block execution');
+        startServerBlock(slice, description);
+        callback();
+        endServerBlock();
+        debugQuery('Server block execution completed');
+      } else {
+        debugQuery('WARNING: No current slice found for server block');
+      }
+    }
+
+    return this;
+  }
+
+  request(query: unknown): FluentQuerySliceBuilder {
+    debugQuery('Setting request for slice %s', this.slice.name);
+    if (typeof query === 'string') {
+      debugQuery('Request is string, length: %d', query.length);
+      this.slice.request = query;
+    } else if (
+      query !== null &&
+      query !== undefined &&
+      typeof query === 'object' &&
+      'kind' in query &&
+      query.kind === 'Document'
+    ) {
+      debugQuery('Request is GraphQL AST Document, converting to SDL');
+      this.slice.request = print(query as ASTNode); // ✅ convert AST to SDL string
+      debugQuery('Converted SDL length: %d', this.slice.request.length);
+    } else {
+      debugQuery('ERROR: Invalid GraphQL query format');
+      throw new Error('Invalid GraphQL query format');
+    }
+    return this;
+  }
+}
+
+class ReactionSliceBuilderImpl implements FluentReactionSliceBuilder {
+  private slice: ReactSlice;
+
+  constructor(name: string, id?: string) {
+    debugReact('Creating reaction slice: %s', name);
+    this.slice = {
+      type: 'react',
+      name,
+      id,
+      server: { specs: { name: '', rules: [] }, data: undefined },
+    };
+    addSlice(this.slice);
+    debugReact('Reaction slice added to flow: %s', name);
+  }
+
+  server(fn: () => void): FluentReactionSliceBuilder;
+  server(description: string, fn: () => void): FluentReactionSliceBuilder;
+  server(descriptionOrFn: string | (() => void), fn?: () => void): FluentReactionSliceBuilder {
+    const description = typeof descriptionOrFn === 'string' ? descriptionOrFn : '';
+    const callback = typeof descriptionOrFn === 'function' ? descriptionOrFn : fn;
+
+    debugReact('Adding server block to slice %s, description: "%s"', this.slice.name, description);
+
+    if (callback) {
+      const slice = getCurrentSlice();
+      if (slice) {
+        debugReact('Starting server block execution');
+        startServerBlock(slice, description);
+        callback();
+        endServerBlock();
+        debugReact('Server block execution completed');
+      } else {
+        debugReact('WARNING: No current slice found for server block');
+      }
+    }
+
+    return this;
+  }
+
+  via(integration: Integration | Integration[]): FluentReactionSliceBuilder {
+    const integrations = Array.isArray(integration) ? integration : [integration];
+    this.slice.via = integrations.map((i) => i.name);
+    debugReact('Set integrations for slice %s: %o', this.slice.name, this.slice.via);
+    return this;
+  }
+
+  retries(count: number): FluentReactionSliceBuilder {
+    debugReact('Setting retries for slice %s: %d', this.slice.name, count);
+    // Store retries in additionalInstructions or metadata
+    this.slice.additionalInstructions = `retries: ${count}`;
+    return this;
+  }
+}
+
+class ExperienceSliceBuilderImpl implements FluentExperienceSliceBuilder {
+  private slice: ExperienceSlice;
+
+  constructor(name: string, id?: string) {
+    debugExperience('Creating experience slice: %s', name);
+    this.slice = {
+      type: 'experience',
+      name,
+      id,
+      client: { description: '', specs: undefined },
+    };
+    addSlice(this.slice);
+    debugExperience('Experience slice added to flow: %s', name);
+  }
+
+  client(fn: () => void): FluentExperienceSliceBuilder;
+  client(description: string, fn: () => void): FluentExperienceSliceBuilder;
+  client(descriptionOrFn: string | (() => void), fn?: () => void): FluentExperienceSliceBuilder {
+    const description = typeof descriptionOrFn === 'string' ? descriptionOrFn : '';
+    const callback = typeof descriptionOrFn === 'function' ? descriptionOrFn : fn;
+
+    debugExperience('Adding client block to slice %s, description: "%s"', this.slice.name, description);
+
+    if (callback) {
+      const slice = getCurrentSlice();
+      if (slice) {
+        debugExperience('Starting client block execution');
+        startClientBlock(slice, description);
+        callback();
+        endClientBlock();
+        debugExperience('Client block execution completed');
+      } else {
+        debugExperience('WARNING: No current slice found for client block');
+      }
+    }
+
+    return this;
+  }
+}
+
+export const command = (name: string, id?: string): FluentCommandSliceBuilder => {
+  debug('Creating command slice: %s', name);
+  return new CommandSliceBuilderImpl(name, id);
+};
+
+export const query = (name: string, id?: string): FluentQuerySliceBuilder => {
+  debug('Creating query slice: %s', name);
+  return new QuerySliceBuilderImpl(name, id);
+};
+
+export const react = (name: string, id?: string): FluentReactionSliceBuilder => {
+  debug('Creating react slice: %s', name);
+  return new ReactionSliceBuilderImpl(name, id);
+};
+
+export const experience = (name: string, id?: string): FluentExperienceSliceBuilder => {
+  debug('Creating experience slice: %s', name);
+  return new ExperienceSliceBuilderImpl(name, id);
+};
+
+export const decide = (name: string, id?: string): FluentCommandSliceBuilder => {
+  debug('Creating command slice via decide alias: %s', name);
+  return new CommandSliceBuilderImpl(name, id);
+};
+
+export const evolve = (name: string, id?: string): FluentQuerySliceBuilder => {
+  debug('Creating query slice via evolve alias: %s', name);
+  return new QuerySliceBuilderImpl(name, id);
+};

package/src/getFlows.cache.specs.ts

@@ -0,0 +1,287 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { getNarratives, clearGetNarrativesCache } from './getNarratives';
+import { InMemoryFileStore, type IFileStore } from '@auto-engineer/file-store';
+import * as flowApi from './narrative';
+import * as fluent from './fluent-builder';
+import * as dataBuilders from './data-narrative-builders';
+import * as typesApi from './types';
+import gql from 'graphql-tag';
+
+const importMap = {
+  '../flow': flowApi,
+  '../fluent-builder': fluent,
+  '../data-flow-builders': dataBuilders,
+  '../types': typesApi,
+  'graphql-tag': { default: gql, gql },
+};
+
+const pattern = /\.(flow)\.(ts)$/;
+
+describe('getNarratives caching', () => {
+  let vfs: IFileStore;
+  const root = '/test';
+
+  beforeEach(() => {
+    vfs = new InMemoryFileStore();
+    clearGetNarrativesCache();
+  });
+
+  it('should rebuild cache when a helper file is modified', async () => {
+    const helperContent1 = `
+      export function formatName(name: string): string {
+        return name.toUpperCase();
+      }
+    `;
+    const flowContent = `
+      import { narrative } from '../narrative';
+      import { formatName } from './helper';
+      
+      narrative('TestFlow', () => {
+        const name = formatName('test');
+      });
+    `;
+
+    await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent1));
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const hash1 = firstCallResult.vfsFiles.sort().join(',');
+
+    const helperContent2 = `
+      export function formatName(name: string): string {
+        return name.toLowerCase(); // Changed implementation
+      }
+    `;
+    await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent2));
+
+    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    const hash2 = secondCallResult.vfsFiles.sort().join(',');
+    expect(hash1).toBe(hash2);
+    expect(secondCallResult.narratives).toBeDefined();
+  });
+
+  it('should rebuild cache when import map changes', async () => {
+    const flowContent = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow', () => {
+        const x = 1;
+      });
+    `;
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const importMap1 = { 'test-module': { default: 'value1' } };
+    const result1 = await getNarratives({ vfs, root, importMap: importMap1, pattern, fastFsScan: true });
+    const importMap2 = { 'test-module': { default: 'value2' } };
+
+    const result2 = await getNarratives({ vfs, root, importMap: importMap2, pattern, fastFsScan: true });
+
+    expect(result1.narratives.length).toBe(result2.narratives.length);
+  });
+
+  it('should rebuild cache when a new dependency is added', async () => {
+    const helperContent1 = `
+      export function getValue(): string {
+        return 'direct';
+      }
+    `;
+    const flowContent = `
+      import { narrative } from '../narrative';
+      import { getValue } from './helper';
+      
+      narrative('TestFlow', () => {
+        const val = getValue();
+      });
+    `;
+
+    await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent1));
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const filesCount1 = firstCallResult.vfsFiles.length;
+
+    const transitiveContent = `
+      export function transitiveHelper(): string {
+        return 'transitive';
+      }
+    `;
+    const helperContent2 = `
+      import { transitiveHelper } from './transitive';
+      
+      export function getValue(): string {
+        return transitiveHelper();
+      }
+    `;
+
+    await vfs.write('/test/transitive.ts', new TextEncoder().encode(transitiveContent));
+    await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent2));
+
+    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    const filesCount2 = secondCallResult.vfsFiles.length;
+    expect(filesCount2).toBeGreaterThan(filesCount1);
+    expect(secondCallResult.vfsFiles.some((f) => f.includes('transitive'))).toBe(true);
+  });
+
+  it('should not rebuild cache when an unrelated file is touched', async () => {
+    const flowContent = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow', () => {
+        const x = 1;
+      });
+    `;
+
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+    await vfs.write('/test/unrelated.txt', new TextEncoder().encode('initial content'));
+
+    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    await vfs.write('/test/unrelated.txt', new TextEncoder().encode('modified content'));
+
+    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    expect(secondCallResult.vfsFiles.some((f) => f.includes('unrelated.txt'))).toBe(false);
+    expect(firstCallResult.vfsFiles).toEqual(secondCallResult.vfsFiles);
+  });
+
+  it('should rebuild cache when a file is deleted from the graph', async () => {
+    const flowContent1 = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow1', () => {
+        const x = 1;
+      });
+    `;
+    const flowContent2 = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow2', () => {
+        const x = 2;
+      });
+    `;
+
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent1));
+    await vfs.write('/test/test2.flow.ts', new TextEncoder().encode(flowContent2));
+
+    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    expect(firstCallResult.narratives.length).toBeGreaterThanOrEqual(2);
+
+    await vfs.remove('/test/test2.flow.ts');
+
+    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    expect(secondCallResult.narratives.length).toBeLessThan(firstCallResult.narratives.length);
+    expect(secondCallResult.vfsFiles.length).toBeLessThan(firstCallResult.vfsFiles.length);
+  });
+
+  it('should rebuild cache when a file is renamed', async () => {
+    const flowContent = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow', () => {
+        const x = 1;
+      });
+    `;
+
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    expect(firstCallResult.vfsFiles.some((f) => f.includes('test.flow.ts'))).toBe(true);
+
+    const content = await vfs.read('/test/test.flow.ts');
+    if (content) {
+      await vfs.write('/test/renamed.flow.ts', content);
+      await vfs.remove('/test/test.flow.ts');
+    }
+
+    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true });
+
+    expect(secondCallResult.vfsFiles.some((f) => f.includes('renamed.flow.ts'))).toBe(true);
+    expect(secondCallResult.vfsFiles.some((f) => f.includes('test.flow.ts'))).toBe(false);
+  });
+
+  it('should handle .d.ts files if they affect the graph', async () => {
+    const dtsContent = `
+      declare module 'custom-module' {
+        export function customFunc(): string;
+      }
+    `;
+    const flowContent = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow', () => {
+        const x: string = 'test';
+      });
+    `;
+
+    await vfs.write('/test/types.d.ts', new TextEncoder().encode(dtsContent));
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const result = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    expect(result.vfsFiles.some((f) => f.endsWith('.d.ts'))).toBe(false);
+  });
+
+  it('should rebuild when import map keys change even with same values', async () => {
+    const flowContent = `
+      import { narrative } from '../narrative';
+      
+      narrative('TestFlow', () => {
+        const x = 1;
+      });
+    `;
+
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const importMap1 = { 'module-a': 'value', 'module-b': 'value' };
+    const result1 = await getNarratives({ vfs, root, importMap: importMap1, pattern, fastFsScan: true });
+    const importMap2 = { 'module-c': 'value', 'module-d': 'value' };
+
+    const result2 = await getNarratives({ vfs, root, importMap: importMap2, pattern, fastFsScan: true });
+
+    expect(result1.narratives).toEqual(result2.narratives); // Same flows
+  });
+
+  it('should handle complex transitive dependency chains', async () => {
+    const chain3Content = `
+      export const DEEP_VALUE = 'deep';
+    `;
+    const chain2Content = `
+      import { DEEP_VALUE } from './chain3';
+      export const MID_VALUE = DEEP_VALUE + '-mid';
+    `;
+    const chain1Content = `
+      import { MID_VALUE } from './chain2';
+      export const TOP_VALUE = MID_VALUE + '-top';
+    `;
+    const flowContent = `
+      import { narrative } from '../narrative';
+      import { TOP_VALUE } from './chain1';
+      
+      narrative('TestFlow', () => {
+        const val = TOP_VALUE;
+      });
+    `;
+
+    await vfs.write('/test/chain3.ts', new TextEncoder().encode(chain3Content));
+    await vfs.write('/test/chain2.ts', new TextEncoder().encode(chain2Content));
+    await vfs.write('/test/chain1.ts', new TextEncoder().encode(chain1Content));
+    await vfs.write('/test/test.flow.ts', new TextEncoder().encode(flowContent));
+
+    const result1 = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+
+    expect(result1.vfsFiles.some((f) => f.includes('chain1'))).toBe(true);
+    expect(result1.vfsFiles.some((f) => f.includes('chain2'))).toBe(true);
+    expect(result1.vfsFiles.some((f) => f.includes('chain3'))).toBe(true);
+
+    const modifiedChain3Content = `
+      export const DEEP_VALUE = 'modified-deep';
+    `;
+    await vfs.write('/test/chain3.ts', new TextEncoder().encode(modifiedChain3Content));
+
+    const result2 = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    expect(result2.vfsFiles.length).toBe(result1.vfsFiles.length);
+  });
+});