@vibe-lang/runtime 0.2.5

package/src/debug/test/ts-debug-integration.test.ts

@@ -0,0 +1,374 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { createInitialState } from '../../runtime/state';
+import { createDebugState, setBreakpoints, getCurrentLocation } from '../state';
+import { debugStep, debugContinue, runWithDebug } from '../runner';
+import {
+  registerTsBlock,
+  getTsBlockMapping,
+  mapTsLocationToVibe,
+  mapVibeLocationToTs,
+  isLocationInTsBlock,
+  clearTsBlockMappings,
+} from '../ts-source-map';
+import {
+  createHandoffState,
+  shouldInitiateHandoff,
+  initiateHandoff,
+  isInTsMode,
+  getCurrentMode,
+} from '../handoff-manager';
+import {
+  createDebugExecutionContext,
+  enterTsBlock,
+  mergeStackFrames,
+  getUnifiedStackTrace,
+} from '../stack-merger';
+import type { RuntimeEvent } from '@vibe-lang/debug-core';
+import type { AIProvider, AIExecutionResult } from '../../runtime';
+
+// Mock AI provider
+const mockAIProvider: AIProvider = {
+  async execute(prompt: string): Promise<AIExecutionResult> {
+    return { value: `Mock: ${prompt.slice(0, 20)}...` };
+  },
+  async generateCode(prompt: string): Promise<AIExecutionResult> {
+    return { value: '// mock' };
+  },
+  async askUser(prompt: string): Promise<string> {
+    return 'mock input';
+  },
+};
+
+describe('TS Block Debug Integration', () => {
+  beforeEach(() => {
+    clearTsBlockMappings();
+  });
+
+  describe('Source mapping for ts blocks in real code', () => {
+    test('parses ts block location from AST', () => {
+      const code = `
+let x = 5
+let result = ts(x) {
+  return x * 2
+}
+`;
+      const ast = parse(code, { file: '/test.vibe' });
+
+      // Find the ts block in the AST
+      const tsBlock = ast.body.find(
+        (stmt: any) => stmt.type === 'LetDeclaration' && stmt.initializer?.type === 'TsBlock'
+      );
+
+      expect(tsBlock).toBeDefined();
+      const tsBlockExpr = (tsBlock as any).initializer;
+      expect(tsBlockExpr.type).toBe('TsBlock');
+      expect(tsBlockExpr.body).toContain('return x * 2');
+
+      // Register the ts block for source mapping
+      const location = tsBlockExpr.location ?? { file: '/test.vibe', line: 3, column: 14 };
+      const id = registerTsBlock(
+        '/test.vibe',
+        location,
+        tsBlockExpr.body,
+        tsBlockExpr.params // params are already strings
+      );
+
+      const mapping = getTsBlockMapping(id);
+      expect(mapping).toBeDefined();
+      expect(mapping?.tsBody).toContain('return x * 2');
+    });
+
+    test('maps ts block line to vibe line correctly', () => {
+      // Simulate a ts block at line 10 of a .vibe file
+      const tsBody = `const doubled = x * 2
+const tripled = x * 3
+return doubled + tripled`;
+
+      const id = registerTsBlock(
+        '/app.vibe',
+        { file: '/app.vibe', line: 10, column: 5 },
+        tsBody,
+        ['x']
+      );
+
+      const mapping = getTsBlockMapping(id)!;
+
+      // Line 1 of TS (after 'use strict') -> line 10 of Vibe
+      expect(mapTsLocationToVibe(mapping, 1, 0).line).toBe(10);
+
+      // Line 2 of TS -> line 11 of Vibe
+      expect(mapTsLocationToVibe(mapping, 2, 0).line).toBe(11);
+
+      // Line 3 of TS -> line 12 of Vibe
+      expect(mapTsLocationToVibe(mapping, 3, 0).line).toBe(12);
+    });
+
+    test('detects when vibe location is inside ts block', () => {
+      const tsBody = `line1
+line2
+line3`;
+
+      registerTsBlock(
+        '/test.vibe',
+        { file: '/test.vibe', line: 20, column: 1 },
+        tsBody,
+        []
+      );
+
+      // Lines 20-22 should be in the TS block
+      expect(isLocationInTsBlock('/test.vibe', 20)).not.toBeNull();
+      expect(isLocationInTsBlock('/test.vibe', 21)).not.toBeNull();
+      expect(isLocationInTsBlock('/test.vibe', 22)).not.toBeNull();
+
+      // Lines outside should not be
+      expect(isLocationInTsBlock('/test.vibe', 19)).toBeNull();
+      expect(isLocationInTsBlock('/test.vibe', 23)).toBeNull();
+    });
+  });
+
+  describe('Handoff detection for ts blocks', () => {
+    test('detects pending ts block execution', () => {
+      const code = `
+let x = 10
+let y = ts(x) {
+  return x + 1
+}
+`;
+      const ast = parse(code, { file: '/test.vibe' });
+      let runtimeState = createInitialState(ast);
+      let handoffState = createHandoffState();
+
+      // Initially no handoff needed
+      let result = shouldInitiateHandoff(runtimeState, handoffState);
+      expect(result.shouldHandoff).toBe(false);
+
+      // Simulate state where ts block is pending
+      const pendingState = {
+        ...runtimeState,
+        status: 'awaiting_ts' as const,
+        pendingTS: {
+          params: ['x'],
+          body: 'return x + 1',
+          paramValues: [10],
+          location: { file: '/test.vibe', line: 3, column: 9 },
+        },
+      };
+
+      result = shouldInitiateHandoff(pendingState as any, handoffState);
+      expect(result.shouldHandoff).toBe(true);
+      expect(result.reason).toBe('ts_block');
+    });
+
+    test('initiates handoff and enters ts mode', () => {
+      const code = 'let x = 1';
+      const ast = parse(code);
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: {
+          params: ['x'],
+          body: 'return x * 2',
+          paramValues: [5],
+          location: { file: '/test.vibe', line: 5, column: 1 },
+        },
+        callStack: [{ locals: {}, functionName: 'main' }],
+      };
+      const debugState = createDebugState();
+      let handoffState = createHandoffState();
+
+      expect(getCurrentMode(handoffState)).toBe('vibe');
+
+      handoffState = initiateHandoff(runtimeState as any, debugState, handoffState, 'ts_block');
+
+      expect(getCurrentMode(handoffState)).toBe('typescript');
+      expect(isInTsMode(handoffState)).toBe(true);
+      expect(handoffState.context.currentTsBlockId).toBeTruthy();
+    });
+  });
+
+  describe('Stack frame merging', () => {
+    test('merges vibe and ts stack frames', () => {
+      const vibeFrames = [
+        { id: 0, name: 'main', source: { file: '/app.vibe', line: 1, column: 1 }, isVibeCode: true },
+        { id: 1, name: 'process', source: { file: '/app.vibe', line: 10, column: 1 }, isVibeCode: true },
+      ];
+
+      const tsFrames = [
+        { id: 0, name: 'calculate', source: { file: '/utils.ts', line: 5, column: 1 }, isVibeCode: false },
+      ];
+
+      // In Vibe mode, only vibe frames
+      let context = createDebugExecutionContext();
+      let merged = mergeStackFrames(vibeFrames, tsFrames, context);
+      expect(merged.length).toBe(2);
+      expect(merged.every(f => f.origin === 'vibe')).toBe(true);
+
+      // In TS mode, ts frames on top + vibe frames below
+      context = enterTsBlock(context, 'ts_1', 1);
+      merged = mergeStackFrames(vibeFrames, tsFrames, context);
+      expect(merged[0].origin).toBe('typescript');
+      expect(merged[0].name).toBe('calculate');
+    });
+
+    test('unified stack trace includes both vibe and ts frames', () => {
+      const code = 'let x = 1';
+      const ast = parse(code, { file: '/test.vibe' });
+      const runtimeState = {
+        ...createInitialState(ast),
+        callStack: [
+          { locals: {}, functionName: 'main', currentLocation: { file: '/test.vibe', line: 1, column: 1 } },
+        ],
+      };
+
+      const tsFrames = [
+        { id: 0, name: 'tsHelper', source: { file: 'ts_block', line: 1, column: 1 }, isVibeCode: false },
+      ];
+
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_1', 1);
+
+      const { stackFrames, totalFrames } = getUnifiedStackTrace(runtimeState as any, tsFrames, context);
+
+      expect(totalFrames).toBeGreaterThan(0);
+      // Should have ts frame on top
+      expect(stackFrames[0].origin).toBe('typescript');
+    });
+  });
+
+  describe('Breakpoints in ts blocks', () => {
+    test('can set breakpoint at ts block location', () => {
+      // Register a ts block
+      registerTsBlock(
+        '/test.vibe',
+        { file: '/test.vibe', line: 10, column: 1 },
+        'return x + 1',
+        ['x']
+      );
+
+      let debugState = createDebugState();
+
+      // Set breakpoint at line 10 (start of ts block)
+      const { debugState: newState, breakpoints } = setBreakpoints(
+        debugState,
+        '/test.vibe',
+        [10]
+      );
+
+      expect(breakpoints.length).toBe(1);
+      expect(breakpoints[0].line).toBe(10);
+      expect(breakpoints[0].verified).toBe(true);
+
+      // Verify breakpoint is associated with ts block location
+      const mapping = isLocationInTsBlock('/test.vibe', 10);
+      expect(mapping).not.toBeNull();
+    });
+
+    test('maps vibe breakpoint to ts line for bun inspector', () => {
+      const id = registerTsBlock(
+        '/test.vibe',
+        { file: '/test.vibe', line: 10, column: 1 },
+        'const a = 1\nconst b = 2\nreturn a + b',
+        []
+      );
+
+      const mapping = getTsBlockMapping(id)!;
+
+      // Breakpoint at vibe line 11 (second line of ts block)
+      const tsLocation = mapVibeLocationToTs(mapping, 11, 0);
+      expect(tsLocation).not.toBeNull();
+      expect(tsLocation?.line).toBe(2); // Second line in TS (after 'use strict')
+    });
+  });
+
+  describe('Debug session with ts block', () => {
+    test('debug session handles ts block execution', async () => {
+      const code = `
+let x = 5
+let doubled = ts(x) {
+  return x * 2
+}
+let result = doubled
+`;
+      const ast = parse(code, { file: '/test.vibe' });
+      let runtimeState = createInitialState(ast);
+      let debugState = createDebugState();
+
+      const events: RuntimeEvent[] = [];
+
+      // Run the debug session
+      const result = await runWithDebug(
+        runtimeState,
+        debugState,
+        mockAIProvider,
+        (e) => events.push(e)
+      );
+
+      // Should complete (ts block should be handled)
+      expect(['completed', 'error'].includes(result.runtimeState.status)).toBe(true);
+    });
+
+    test('stepping through code with ts block', () => {
+      const code = `
+let x = 1
+let y = 2
+let z = x + y
+`;
+      const ast = parse(code, { file: '/test.vibe' });
+      let runtimeState = createInitialState(ast);
+      let debugState = createDebugState();
+
+      // Step through each statement
+      let stepCount = 0;
+      while (runtimeState.status === 'running' && stepCount < 20) {
+        const result = debugStep(runtimeState, debugState);
+        runtimeState = result.runtimeState;
+        debugState = result.debugState;
+        stepCount++;
+      }
+
+      expect(runtimeState.status).toBe('completed');
+    });
+  });
+});
+
+describe('Imported TS Function Debug Integration', () => {
+  test('detects pending imported ts function call', () => {
+    const code = 'let x = 1';
+    const ast = parse(code);
+    const runtimeState = {
+      ...createInitialState(ast),
+      status: 'awaiting_ts' as const,
+      pendingImportedTsCall: {
+        funcName: 'calculateSum',
+        args: [1, 2, 3],
+      },
+    };
+    const handoffState = createHandoffState();
+
+    const result = shouldInitiateHandoff(runtimeState as any, handoffState);
+    expect(result.shouldHandoff).toBe(true);
+    expect(result.reason).toBe('ts_import');
+  });
+
+  test('initiates handoff for ts import', () => {
+    const code = 'let x = 1';
+    const ast = parse(code);
+    const runtimeState = {
+      ...createInitialState(ast),
+      status: 'awaiting_ts' as const,
+      pendingImportedTsCall: {
+        funcName: 'myTsFunction',
+        args: [42],
+      },
+      callStack: [{ locals: {} }],
+    };
+    const debugState = createDebugState();
+    let handoffState = createHandoffState();
+
+    handoffState = initiateHandoff(runtimeState as any, debugState, handoffState, 'ts_import');
+
+    expect(isInTsMode(handoffState)).toBe(true);
+    expect(handoffState.context.currentTsImport).toBe('myTsFunction');
+  });
+});

package/src/debug/test/ts-import-tracker.test.ts

@@ -0,0 +1,125 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+  registerTsImport,
+  getTsImportInfo,
+  isTsImportCall,
+  setTsImportEntryLine,
+  registerTempBreakpoint,
+  popTempBreakpoint,
+  clearTempBreakpoints,
+  getAllTsImports,
+  getTsImportsForFile,
+  clearTsImports,
+  buildTsEntryPointId,
+  parseTsEntryPointId,
+} from '../ts-import-tracker';
+
+describe('TS Import Tracker', () => {
+  beforeEach(() => {
+    clearTsImports();
+  });
+
+  describe('registerTsImport', () => {
+    test('registers a TS import', () => {
+      registerTsImport('add', '/utils.ts', 'add', '/main.vibe', 5);
+
+      const info = getTsImportInfo('/main.vibe', 'add');
+      expect(info).toBeDefined();
+      expect(info?.vibeName).toBe('add');
+      expect(info?.tsFile).toBe('/utils.ts');
+      expect(info?.tsFunctionName).toBe('add');
+      expect(info?.importedBy).toBe('/main.vibe');
+      expect(info?.importLine).toBe(5);
+    });
+  });
+
+  describe('isTsImportCall', () => {
+    test('returns true for registered import', () => {
+      registerTsImport('calculate', '/math.ts', 'calculate', '/app.vibe', 10);
+
+      expect(isTsImportCall('/app.vibe', 'calculate')).toBe(true);
+    });
+
+    test('returns false for unregistered function', () => {
+      expect(isTsImportCall('/app.vibe', 'unknown')).toBe(false);
+    });
+  });
+
+  describe('setTsImportEntryLine', () => {
+    test('sets entry line for registered import', () => {
+      registerTsImport('foo', '/foo.ts', 'foo', '/main.vibe', 1);
+      setTsImportEntryLine('/main.vibe', 'foo', 42);
+
+      const info = getTsImportInfo('/main.vibe', 'foo');
+      expect(info?.entryLine).toBe(42);
+    });
+  });
+
+  describe('temporary breakpoints', () => {
+    test('registers and pops temp breakpoint', () => {
+      registerTempBreakpoint('/utils.ts', 10, 'bp_123');
+
+      const id = popTempBreakpoint('/utils.ts', 10);
+      expect(id).toBe('bp_123');
+
+      // Should be gone after pop
+      const id2 = popTempBreakpoint('/utils.ts', 10);
+      expect(id2).toBeUndefined();
+    });
+
+    test('clearTempBreakpoints returns all and clears', () => {
+      registerTempBreakpoint('/a.ts', 5, 'bp_1');
+      registerTempBreakpoint('/b.ts', 10, 'bp_2');
+
+      const all = clearTempBreakpoints();
+      expect(all.size).toBe(2);
+      expect(all.get('/a.ts:5')).toBe('bp_1');
+      expect(all.get('/b.ts:10')).toBe('bp_2');
+
+      // Should be empty now
+      const empty = clearTempBreakpoints();
+      expect(empty.size).toBe(0);
+    });
+  });
+
+  describe('getAllTsImports', () => {
+    test('returns all registered imports', () => {
+      registerTsImport('a', '/a.ts', 'a', '/main.vibe', 1);
+      registerTsImport('b', '/b.ts', 'b', '/main.vibe', 2);
+
+      const all = getAllTsImports();
+      expect(all.length).toBe(2);
+    });
+  });
+
+  describe('getTsImportsForFile', () => {
+    test('returns imports for specific file', () => {
+      registerTsImport('a', '/a.ts', 'a', '/main.vibe', 1);
+      registerTsImport('b', '/b.ts', 'b', '/other.vibe', 2);
+      registerTsImport('c', '/c.ts', 'c', '/main.vibe', 3);
+
+      const mainImports = getTsImportsForFile('/main.vibe');
+      expect(mainImports.length).toBe(2);
+      expect(mainImports.map(i => i.vibeName).sort()).toEqual(['a', 'c']);
+    });
+  });
+
+  describe('entry point ID helpers', () => {
+    test('buildTsEntryPointId creates unique ID', () => {
+      const id = buildTsEntryPointId('/utils.ts', 'calculate');
+      expect(id).toBe('ts:/utils.ts:calculate');
+    });
+
+    test('parseTsEntryPointId extracts components', () => {
+      const parsed = parseTsEntryPointId('ts:/path/to/file.ts:myFunc');
+      expect(parsed).not.toBeNull();
+      expect(parsed?.tsFile).toBe('/path/to/file.ts');
+      expect(parsed?.functionName).toBe('myFunc');
+    });
+
+    test('parseTsEntryPointId returns null for invalid format', () => {
+      expect(parseTsEntryPointId('invalid')).toBeNull();
+      expect(parseTsEntryPointId('wrong:format')).toBeNull();
+    });
+  });
+});

package/src/debug/test/ts-source-map.test.ts

@@ -0,0 +1,169 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+  registerTsBlock,
+  getTsBlockMapping,
+  setScriptId,
+  findMappingByScriptId,
+  mapTsLocationToVibe,
+  mapVibeLocationToTs,
+  isLocationInTsBlock,
+  getMappingsForFile,
+  clearTsBlockMappings,
+  getAllMappings,
+} from '../ts-source-map';
+
+describe('TS Block Source Mapping', () => {
+  beforeEach(() => {
+    clearTsBlockMappings();
+  });
+
+  describe('registerTsBlock', () => {
+    test('registers a TS block and returns unique ID', () => {
+      const id = registerTsBlock(
+        '/test.vibe',
+        { file: '/test.vibe', line: 10, column: 5 },
+        'return x + y',
+        ['x', 'y']
+      );
+
+      expect(id).toMatch(/^ts_block_\d+$/);
+
+      const mapping = getTsBlockMapping(id);
+      expect(mapping).toBeDefined();
+      expect(mapping?.vibeFile).toBe('/test.vibe');
+      expect(mapping?.vibeStartLine).toBe(10);
+      expect(mapping?.vibeStartColumn).toBe(5);
+      expect(mapping?.tsBody).toBe('return x + y');
+      expect(mapping?.params).toEqual(['x', 'y']);
+    });
+
+    test('generates unique IDs for each block', () => {
+      const id1 = registerTsBlock('/a.vibe', { file: '/a.vibe', line: 1, column: 1 }, 'a', []);
+      const id2 = registerTsBlock('/b.vibe', { file: '/b.vibe', line: 2, column: 1 }, 'b', []);
+
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe('script ID association', () => {
+    test('associates script ID with mapping', () => {
+      const id = registerTsBlock('/test.vibe', { file: '/test.vibe', line: 5, column: 1 }, 'code', []);
+
+      setScriptId(id, 'script_123');
+
+      const mapping = getTsBlockMapping(id);
+      expect(mapping?.scriptId).toBe('script_123');
+    });
+
+    test('finds mapping by script ID', () => {
+      const id = registerTsBlock('/test.vibe', { file: '/test.vibe', line: 5, column: 1 }, 'code', []);
+      setScriptId(id, 'script_456');
+
+      const found = findMappingByScriptId('script_456');
+      expect(found).toBeDefined();
+      expect(found?.vibeStartLine).toBe(5);
+    });
+
+    test('returns undefined for unknown script ID', () => {
+      const found = findMappingByScriptId('unknown');
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe('mapTsLocationToVibe', () => {
+    test('maps TS line to Vibe line', () => {
+      const id = registerTsBlock('/test.vibe', { file: '/test.vibe', line: 10, column: 3 }, 'line1\nline2\nline3', []);
+      const mapping = getTsBlockMapping(id)!;
+
+      // Line 1 of TS (after 'use strict') maps to line 10 of Vibe
+      const loc1 = mapTsLocationToVibe(mapping, 1, 0);
+      expect(loc1.line).toBe(10);
+      expect(loc1.column).toBe(3);
+
+      // Line 2 of TS maps to line 11 of Vibe
+      const loc2 = mapTsLocationToVibe(mapping, 2, 5);
+      expect(loc2.line).toBe(11);
+      expect(loc2.column).toBe(5);
+    });
+  });
+
+  describe('mapVibeLocationToTs', () => {
+    test('maps Vibe location to TS location', () => {
+      const id = registerTsBlock('/test.vibe', { file: '/test.vibe', line: 10, column: 3 }, 'line1\nline2\nline3', []);
+      const mapping = getTsBlockMapping(id)!;
+
+      // Vibe line 10 maps to TS line 1 (after 'use strict')
+      const ts1 = mapVibeLocationToTs(mapping, 10, 5);
+      expect(ts1).not.toBeNull();
+      expect(ts1?.line).toBe(1);
+      expect(ts1?.column).toBe(2); // 5 - 3 start column
+
+      // Vibe line 11 maps to TS line 2
+      const ts2 = mapVibeLocationToTs(mapping, 11, 0);
+      expect(ts2).not.toBeNull();
+      expect(ts2?.line).toBe(2);
+    });
+
+    test('returns null for location outside TS block', () => {
+      const id = registerTsBlock('/test.vibe', { file: '/test.vibe', line: 10, column: 1 }, 'single', []);
+      const mapping = getTsBlockMapping(id)!;
+
+      expect(mapVibeLocationToTs(mapping, 5, 0)).toBeNull();
+      expect(mapVibeLocationToTs(mapping, 15, 0)).toBeNull();
+    });
+  });
+
+  describe('isLocationInTsBlock', () => {
+    test('returns mapping when location is in TS block', () => {
+      registerTsBlock('/test.vibe', { file: '/test.vibe', line: 10, column: 1 }, 'line1\nline2\nline3', []);
+
+      expect(isLocationInTsBlock('/test.vibe', 10)).not.toBeNull();
+      expect(isLocationInTsBlock('/test.vibe', 11)).not.toBeNull();
+      expect(isLocationInTsBlock('/test.vibe', 12)).not.toBeNull();
+    });
+
+    test('returns null when location is outside TS block', () => {
+      registerTsBlock('/test.vibe', { file: '/test.vibe', line: 10, column: 1 }, 'single', []);
+
+      expect(isLocationInTsBlock('/test.vibe', 5)).toBeNull();
+      expect(isLocationInTsBlock('/test.vibe', 15)).toBeNull();
+    });
+
+    test('returns null for different file', () => {
+      registerTsBlock('/a.vibe', { file: '/a.vibe', line: 10, column: 1 }, 'code', []);
+
+      expect(isLocationInTsBlock('/b.vibe', 10)).toBeNull();
+    });
+  });
+
+  describe('getMappingsForFile', () => {
+    test('returns all mappings for a file', () => {
+      registerTsBlock('/a.vibe', { file: '/a.vibe', line: 5, column: 1 }, 'block1', []);
+      registerTsBlock('/a.vibe', { file: '/a.vibe', line: 15, column: 1 }, 'block2', []);
+      registerTsBlock('/b.vibe', { file: '/b.vibe', line: 10, column: 1 }, 'other', []);
+
+      const mappings = getMappingsForFile('/a.vibe');
+      expect(mappings.length).toBe(2);
+      expect(mappings.map(m => m.vibeStartLine).sort((a, b) => a - b)).toEqual([5, 15]);
+    });
+
+    test('returns empty array for file with no TS blocks', () => {
+      registerTsBlock('/a.vibe', { file: '/a.vibe', line: 5, column: 1 }, 'code', []);
+
+      expect(getMappingsForFile('/c.vibe')).toEqual([]);
+    });
+  });
+
+  describe('clearTsBlockMappings', () => {
+    test('clears all mappings', () => {
+      registerTsBlock('/a.vibe', { file: '/a.vibe', line: 1, column: 1 }, 'a', []);
+      registerTsBlock('/b.vibe', { file: '/b.vibe', line: 2, column: 1 }, 'b', []);
+
+      expect(getAllMappings().size).toBe(2);
+
+      clearTsBlockMappings();
+
+      expect(getAllMappings().size).toBe(0);
+    });
+  });
+});