hermes-test 1.0.1 → 1.0.3

package/src/fetch.ts

@@ -75,13 +75,17 @@ function fakeFetch(input: any, init?: any): any {
   const method = (init?.method || 'GET').toUpperCase();
   let body = init?.body;
   if (typeof body === 'string') {
-    try { body = JSON.parse(body); } catch {}
+    try {
+      body = JSON.parse(body);
+    } catch {}
   }
 
   const reqHeaders: Record<string, string> = {};
   if (init?.headers) {
     if (typeof init.headers.forEach === 'function') {
-      init.headers.forEach((v: string, k: string) => { reqHeaders[k] = v; });
+      init.headers.forEach((v: string, k: string) => {
+        reqHeaders[k] = v;
+      });
     } else {
       Object.assign(reqHeaders, init.headers);
     }
@@ -122,14 +126,24 @@ function fakeFetch(input: any, init?: any): any {
       has: (k: string) => k.toLowerCase() in responseHeaders,
     },
     json: () => Promise.resolve(responseBody),
-    text: () => Promise.resolve(typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody)),
-    clone: function() { return this; },
+    text: () =>
+      Promise.resolve(
+        typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody),
+      ),
+    clone: function () {
+      return this;
+    },
   });
 }
 
 // --- Public API ---
 
-function createHandler(method: Method, url: string | RegExp, response: MockResponseInit | ((req: MockRequest) => MockResponseInit), once = false): MockHandler {
+function createHandler(
+  method: Method,
+  url: string | RegExp,
+  response: MockResponseInit | ((req: MockRequest) => MockResponseInit),
+  once = false,
+): MockHandler {
   const handler = typeof response === 'function' ? response : () => response;
   return { method, url, handler, once };
 }

package/src/harness.ts

@@ -4,13 +4,18 @@
 // Console interceptor — replace console with print()-based output.
 // Hermes's native print() writes to stdout and is always available.
 // This works in all bundle modes (single, split, watch).
-(function() {
+(function () {
   const p = (globalThis as any).print || (() => {});
   function fmt(...args: any[]) {
-    return args.map((a: any) => {
-      try { return typeof a === 'string' ? a : JSON.stringify(a, null, 2); }
-      catch { return String(a); }
-    }).join(' ');
+    return args
+      .map((a: any) => {
+        try {
+          return typeof a === 'string' ? a : JSON.stringify(a, null, 2);
+        } catch {
+          return String(a);
+        }
+      })
+      .join(' ');
   }
   (globalThis as any).console = {
     log: (...args: any[]) => p(fmt(...args)),
@@ -32,8 +37,22 @@ import { spy, spyOn, clearAllMocks } from './spy';
 import { renderHook, act, waitFor } from './hooks';
 import { render, fireEvent } from './render';
 import { useMock, mockModule, resetMocks, resetMockModulePatches } from './mock';
-import { mockFetch, mockFetchUse, mockFetchReset, mockFetchClear, http, HttpResponse } from './fetch';
-import { useFakeTimers, useRealTimers, advanceTimersByTime, runAllTimers, getTimerCount, advanceTimersToNextTimer } from './timers';
+import {
+  mockFetch,
+  mockFetchUse,
+  mockFetchReset,
+  mockFetchClear,
+  http,
+  HttpResponse,
+} from './fetch';
+import {
+  useFakeTimers,
+  useRealTimers,
+  advanceTimersByTime,
+  runAllTimers,
+  getTimerCount,
+  advanceTimersToNextTimer,
+} from './timers';
 
 type TestFn = ((ctx: TestContext) => void | Promise<void>) | (() => void | Promise<void>);
 type TestContext = {
@@ -83,11 +102,11 @@ function test(name: string, fn: TestFn, options?: TestOptions): void {
   });
 }
 
-test.only = function(name: string, fn: TestFn): void {
+test.only = function (name: string, fn: TestFn): void {
   test(name, fn, { only: true });
 };
 
-test.skip = function(name: string, fn: TestFn): void {
+test.skip = function (name: string, fn: TestFn): void {
   test(name, fn, { skip: true });
 };
 
@@ -156,8 +175,14 @@ function flushAsync<T = any>(promise: Promise<T> | T): T {
   let error: any;
   let settled = false;
   (promise as Promise<T>).then(
-    (v) => { result = v; settled = true; },
-    (e) => { error = e; settled = true; }
+    v => {
+      result = v;
+      settled = true;
+    },
+    e => {
+      error = e;
+      settled = true;
+    },
   );
   // drainMicrotasks() flushes all pending microtasks. One call should settle
   // most promises. Loop only as safety net for edge cases (macrotask scheduling).
@@ -199,10 +224,14 @@ function _printFileResult(file: string, passed: number, failed: number, duration
       // Clear progress line before printing failure
       _print(`\r\x1b[K`);
     }
-    _print(` \x1b[31mFAIL\x1b[0m  ${file} \x1b[2m(${passed} passed, ${failed} failed)\x1b[0m${time}\n`);
+    _print(
+      ` \x1b[31mFAIL\x1b[0m  ${file} \x1b[2m(${passed} passed, ${failed} failed)\x1b[0m${time}\n`,
+    );
   } else if ((globalThis as any).__HT_coverage) {
     // In-place progress counter
-    _print(`\r\x1b[K \x1b[2mRunning...\x1b[0m ${_filesCompleted}/${_totalFiles} files (${_testsCompleted} tests)`);
+    _print(
+      `\r\x1b[K \x1b[2mRunning...\x1b[0m ${_filesCompleted}/${_totalFiles} files (${_testsCompleted} tests)`,
+    );
   } else {
     _print(` \x1b[32mPASS\x1b[0m  ${file} \x1b[2m(${total} tests)\x1b[0m${time}\n`);
   }
@@ -225,18 +254,35 @@ function formatTestError(e: any): string {
 
   // Filter to application frames only (skip react internals, harness, native)
   const skipFn = new Set([
-    'anonymous', 'global', '__init', 'apply', 'map',
-    'react-stack-bottom-frame', 'proxy trap',
+    'anonymous',
+    'global',
+    '__init',
+    'apply',
+    'map',
+    'react-stack-bottom-frame',
+    'proxy trap',
   ]);
   const skipPrefix = [
-    'render', 'run', 'perform', 'work', 'flush', 'begin', 'update',
-    'reconcile', 'create', 'complete', 'commit', 'process',
+    'render',
+    'run',
+    'perform',
+    'work',
+    'flush',
+    'begin',
+    'update',
+    'reconcile',
+    'create',
+    'complete',
+    'commit',
+    'process',
   ];
   const appFrames = frames.filter(f => {
     if (skipFn.has(f.fn)) return false;
     if (f.file.includes('harness') || f.file.includes('runner')) return false;
     if (f.fn === '' && !f.file.includes('/src/') && !f.file.includes('packages/')) return false;
-    for (const p of skipPrefix) { if (f.fn.startsWith(p)) return false; }
+    for (const p of skipPrefix) {
+      if (f.fn.startsWith(p)) return false;
+    }
     return true;
   });
 
@@ -246,7 +292,11 @@ function formatTestError(e: any): string {
     cleanStack += '\n';
     for (const f of appFrames.slice(0, 8)) {
       // esbuild names __esm blocks with source paths like "src/utils/string.ts"
-      const loc = f.fn.includes('/') ? f.fn : (f.fn ? f.fn + ' (' + f.file + ':' + f.line + ')' : f.file + ':' + f.line);
+      const loc = f.fn.includes('/')
+        ? f.fn
+        : f.fn
+        ? f.fn + ' (' + f.file + ':' + f.line + ')'
+        : f.file + ':' + f.line;
       cleanStack += '\n    at ' + loc;
     }
   }
@@ -265,15 +315,23 @@ function formatTestError(e: any): string {
       const nmMatch = srcPath.match(/node_modules\/((?:@[^/]+\/)?[^/]+)/);
       if (nmMatch) {
         const pkg = nmMatch[1];
-        hint = '\n\n  "' + pkg + '" crashed during initialization (native dependency).'
-          + '\n  Add to externals in hermes-test.config.json:\n\n'
-          + '    { "externals": ["' + pkg + '"] }\n'
-          + '\n  Or mock the module that imports it with ht.mock().\n';
+        hint =
+          '\n\n  "' +
+          pkg +
+          '" crashed during initialization (native dependency).' +
+          '\n  Add to externals in hermes-test.config.json:\n\n' +
+          '    { "externals": ["' +
+          pkg +
+          '"] }\n' +
+          '\n  Or mock the module that imports it with ht.mock().\n';
       } else {
         const cleanPath = srcPath.replace(/\/index\.(tsx?|jsx?)$/, '');
-        hint = '\n\n  Module "' + cleanPath + '" crashed during initialization.'
-          + '\n  A dependency uses an API not available in Hermes.'
-          + '\n  Mock it with ht.mock() or add the native dep to externals.\n';
+        hint =
+          '\n\n  Module "' +
+          cleanPath +
+          '" crashed during initialization.' +
+          '\n  A dependency uses an API not available in Hermes.' +
+          '\n  Mock it with ht.mock() or add the native dep to externals.\n';
       }
       break;
     }
@@ -288,9 +346,18 @@ function formatTestError(e: any): string {
           if (importMap[k] === modPath && siblings.indexOf(k) === -1) siblings.push(k);
         }
         const mockBody = siblings.map(s => '    ' + s + ': () => {}').join(',\n');
-        hint = '\n\n  "' + fnName + '" from "' + modPath + '" failed.'
-          + '\n  Add this mock to your test file:\n\n'
-          + "    ht.mock('" + modPath + "', () => ({\n" + mockBody + '\n    }));\n';
+        hint =
+          '\n\n  "' +
+          fnName +
+          '" from "' +
+          modPath +
+          '" failed.' +
+          '\n  Add this mock to your test file:\n\n' +
+          "    ht.mock('" +
+          modPath +
+          "', () => ({\n" +
+          mockBody +
+          '\n    }));\n';
         break;
       }
     }
@@ -301,7 +368,7 @@ function formatTestError(e: any): string {
 
 function runTests(): TestResult[] {
   const results: TestResult[] = [];
-  const hasOnly = tests.some((t) => t.options.only);
+  const hasOnly = tests.some(t => t.options.only);
 
   // Count unique files for progress counter
   const uniqueFiles = new Set(tests.map(t => t.file));
@@ -317,7 +384,7 @@ function runTests(): TestResult[] {
   let _fileFailures: { name: string; error: string }[] = [];
 
   function _flushFileResult() {
-    if (_currentFile && (_filePassed + _fileFailed) > 0) {
+    if (_currentFile && _filePassed + _fileFailed > 0) {
       _printFileResult(_currentFile, _filePassed, _fileFailed, Date.now() - _fileStart);
       // Print failure details
       for (const f of _fileFailures) {
@@ -476,7 +543,9 @@ function registerCrash(file: string, error: string): void {
   const formatted = formatTestError({ message: error.split('\n')[0], stack: error });
   tests.push({
     name: `[CRASH] ${file}`,
-    fn: () => { throw new Error(formatted); },
+    fn: () => {
+      throw new Error(formatted);
+    },
     options: {},
     file,
   });
@@ -553,4 +622,31 @@ const unmock = (_modulePath: string) => {}; // Bundler directive — no runtime
   advanceTimersToNextTimer,
 };
 
-export { test, expect, spy, spyOn, clearAllMocks, group, describe, beforeEach, afterEach, beforeAll, afterAll, renderHook, act, waitFor, render, fireEvent, useMock, http, HttpResponse, flushAsync, useFakeTimers, useRealTimers, advanceTimersByTime, runAllTimers, getTimerCount, advanceTimersToNextTimer };
+export {
+  test,
+  expect,
+  spy,
+  spyOn,
+  clearAllMocks,
+  group,
+  describe,
+  beforeEach,
+  afterEach,
+  beforeAll,
+  afterAll,
+  renderHook,
+  act,
+  waitFor,
+  render,
+  fireEvent,
+  useMock,
+  http,
+  HttpResponse,
+  flushAsync,
+  useFakeTimers,
+  useRealTimers,
+  advanceTimersByTime,
+  runAllTimers,
+  getTimerCount,
+  advanceTimersToNextTimer,
+};

package/src/hooks.ts

@@ -14,7 +14,10 @@ function getReact(): typeof import('react') {
 
 function getReconcilerModule(): any {
   const R = (globalThis as any).__HT_Reconciler;
-  if (!R) throw new Error('react-reconciler not available. Make sure it is installed (it ships with hermes-test).');
+  if (!R)
+    throw new Error(
+      'react-reconciler not available. Make sure it is installed (it ships with hermes-test).',
+    );
   return R;
 }
 
@@ -33,55 +36,129 @@ const hostConfig = {
   supportsMicrotasks: true,
   isPrimaryRenderer: true,
   warnsIfNotActing: true,
-  createInstance(type: string, props: any) { const { children: _c, ...rest } = props; return { type, props: rest, children: [] }; },
-  createTextInstance(text: string) { return { type: '__TEXT__', props: {}, text, children: [] }; },
-  appendInitialChild(p: any, c: any) { p.children.push(c); c._parent = p; },
-  appendChild(p: any, c: any) { p.children.push(c); c._parent = p; },
-  appendChildToContainer(p: any, c: any) { p.children.push(c); c._parent = p; },
-  removeChild(p: any, c: any) { const i = p.children.indexOf(c); if (i !== -1) p.children.splice(i, 1); },
-  removeChildFromContainer(p: any, c: any) { const i = p.children.indexOf(c); if (i !== -1) p.children.splice(i, 1); },
-  insertBefore(p: any, c: any, b: any) { const i = p.children.indexOf(b); p.children.splice(i, 0, c); c._parent = p; },
-  insertInContainerBefore(p: any, c: any, b: any) { const i = p.children.indexOf(b); p.children.splice(i, 0, c); c._parent = p; },
-  commitUpdate(inst: any, _type: any, _oldProps: any, newProps: any) { const { children: _c, ...rest } = newProps; inst.props = rest; },
-  commitTextUpdate(inst: any, _oldText: string, newText: string) { inst.text = newText; },
+  createInstance(type: string, props: any) {
+    const { children: _c, ...rest } = props;
+    return { type, props: rest, children: [] };
+  },
+  createTextInstance(text: string) {
+    return { type: '__TEXT__', props: {}, text, children: [] };
+  },
+  appendInitialChild(p: any, c: any) {
+    p.children.push(c);
+    c._parent = p;
+  },
+  appendChild(p: any, c: any) {
+    p.children.push(c);
+    c._parent = p;
+  },
+  appendChildToContainer(p: any, c: any) {
+    p.children.push(c);
+    c._parent = p;
+  },
+  removeChild(p: any, c: any) {
+    const i = p.children.indexOf(c);
+    if (i !== -1) p.children.splice(i, 1);
+  },
+  removeChildFromContainer(p: any, c: any) {
+    const i = p.children.indexOf(c);
+    if (i !== -1) p.children.splice(i, 1);
+  },
+  insertBefore(p: any, c: any, b: any) {
+    const i = p.children.indexOf(b);
+    p.children.splice(i, 0, c);
+    c._parent = p;
+  },
+  insertInContainerBefore(p: any, c: any, b: any) {
+    const i = p.children.indexOf(b);
+    p.children.splice(i, 0, c);
+    c._parent = p;
+  },
+  commitUpdate(inst: any, _type: any, _oldProps: any, newProps: any) {
+    const { children: _c, ...rest } = newProps;
+    inst.props = rest;
+  },
+  commitTextUpdate(inst: any, _oldText: string, newText: string) {
+    inst.text = newText;
+  },
   commitMount() {},
-  prepareForCommit() { return null; },
+  prepareForCommit() {
+    return null;
+  },
   resetAfterCommit() {},
   resetTextContent() {},
-  finalizeInitialChildren() { return false; },
-  shouldSetTextContent() { return false; },
-  getRootHostContext() { return null; },
-  getChildHostContext(ctx: any) { return ctx; },
-  getPublicInstance(inst: any) { return inst; },
-  prepareUpdate() { return {}; },
-  clearContainer(c: any) { c.children = []; },
+  finalizeInitialChildren() {
+    return false;
+  },
+  shouldSetTextContent() {
+    return false;
+  },
+  getRootHostContext() {
+    return null;
+  },
+  getChildHostContext(ctx: any) {
+    return ctx;
+  },
+  getPublicInstance(inst: any) {
+    return inst;
+  },
+  prepareUpdate() {
+    return {};
+  },
+  clearContainer(c: any) {
+    c.children = [];
+  },
   scheduleTimeout: (globalThis as any).setTimeout || ((fn: any) => fn()),
   cancelTimeout: (globalThis as any).clearTimeout || (() => {}),
   noTimeout: -1,
-  scheduleMicrotask: typeof queueMicrotask === 'function' ? queueMicrotask : (fn: any) => Promise.resolve().then(fn),
-  getCurrentEventPriority() { return getReconcilerConstants().DefaultEventPriority ?? 0; },
-  setCurrentUpdatePriority(priority: number) { currentUpdatePriority = priority; },
-  getCurrentUpdatePriority() { return currentUpdatePriority; },
-  resolveUpdatePriority() { return currentUpdatePriority || (getReconcilerConstants().DefaultEventPriority ?? 0); },
-  shouldAttemptEagerTransition() { return false; },
+  scheduleMicrotask:
+    typeof queueMicrotask === 'function' ? queueMicrotask : (fn: any) => Promise.resolve().then(fn),
+  getCurrentEventPriority() {
+    return getReconcilerConstants().DefaultEventPriority ?? 0;
+  },
+  setCurrentUpdatePriority(priority: number) {
+    currentUpdatePriority = priority;
+  },
+  getCurrentUpdatePriority() {
+    return currentUpdatePriority;
+  },
+  resolveUpdatePriority() {
+    return currentUpdatePriority || (getReconcilerConstants().DefaultEventPriority ?? 0);
+  },
+  shouldAttemptEagerTransition() {
+    return false;
+  },
   trackSchedulerEvent() {},
-  resolveEventType() { return ''; },
-  resolveEventTimeStamp() { return -1.1; },
+  resolveEventType() {
+    return '';
+  },
+  resolveEventTimeStamp() {
+    return -1.1;
+  },
   requestPostPaintCallback() {},
-  maySuspendCommit() { return false; },
-  preloadInstance() { return true; },
+  maySuspendCommit() {
+    return false;
+  },
+  preloadInstance() {
+    return true;
+  },
   startSuspendingCommit() {},
   suspendInstance() {},
-  waitForCommitToBeReady() { return null; },
+  waitForCommitToBeReady() {
+    return null;
+  },
   NotPendingTransition: null,
   resetFormInstance() {},
   hideInstance() {},
   unhideInstance() {},
   hideTextInstance() {},
   unhideTextInstance() {},
-  getInstanceFromNode() { return null; },
+  getInstanceFromNode() {
+    return null;
+  },
   prepareScopeUpdate() {},
-  getInstanceFromScope() { return null; },
+  getInstanceFromScope() {
+    return null;
+  },
   detachDeletedInstance() {},
   beforeActiveInstanceBlur() {},
   afterActiveInstanceBlur() {},
@@ -133,8 +210,13 @@ export function act(fn: () => void | Promise<void>): void {
         let settled = false;
         let error: any;
         (result as Promise<void>).then(
-          () => { settled = true; },
-          (e: any) => { settled = true; error = e; }
+          () => {
+            settled = true;
+          },
+          (e: any) => {
+            settled = true;
+            error = e;
+          },
         );
         drain();
         if (error) throw error;
@@ -152,7 +234,7 @@ export function act(fn: () => void | Promise<void>): void {
 
 export function renderHook<T>(
   hookFn: (props?: any) => T,
-  options?: { initialProps?: any; wrapper?: any }
+  options?: { initialProps?: any; wrapper?: any },
 ): HookResult<T> {
   const history: T[] = [];
   let currentValue: T;
@@ -164,13 +246,17 @@ export function renderHook<T>(
   const root = reconciler.createContainer(
     container,
     0, // LegacyRoot — effects fire synchronously in act()
-    null,  // hydrationCallbacks
+    null, // hydrationCallbacks
     false, // isStrictMode
     false, // concurrentUpdatesByDefaultOverride
-    '',    // identifierPrefix
-    (err: any) => { throw err; }, // onUncaughtError
-    (err: any) => { throw err; }, // onCaughtError
-    null,  // onRecoverableError
+    '', // identifierPrefix
+    (err: any) => {
+      throw err;
+    }, // onUncaughtError
+    (err: any) => {
+      throw err;
+    }, // onCaughtError
+    null, // onRecoverableError
     () => {}, // onDefaultTransitionIndicator
   );
 
@@ -223,13 +309,15 @@ export function renderHook<T>(
 
 export function waitFor<T>(
   predicate: () => T | false | null | undefined,
-  options?: { timeout?: number; interval?: number }
+  options?: { timeout?: number; interval?: number },
 ): T {
   const timeout = options?.timeout ?? 1000;
   const start = Date.now();
 
   for (let attempt = 0; attempt < 100; attempt++) {
-    act(() => { drain(); });
+    act(() => {
+      drain();
+    });
     drain();
 
     const result = predicate();

package/src/index.ts

@@ -28,8 +28,12 @@ function _makeCtx(store: any) {
     wrapper,
     dispatch: store.dispatch.bind(store),
     getState: store.getState.bind(store),
-    setState(state: Record<string, any>) { store.dispatch({ type: '__SET_STATE__', payload: state }); },
-    patchState(partial: Record<string, any>) { store.dispatch({ type: '__PATCH__', payload: partial }); },
+    setState(state: Record<string, any>) {
+      store.dispatch({ type: '__SET_STATE__', payload: state });
+    },
+    patchState(partial: Record<string, any>) {
+      store.dispatch({ type: '__PATCH__', payload: partial });
+    },
     renderHookWithReduxStore<T>(hookFn: (props?: any) => T, options?: { initialProps?: any }) {
       return ht.renderHook(hookFn, { ...options, wrapper });
     },
@@ -38,11 +42,13 @@ function _makeCtx(store: any) {
 
 export function withStore(initialState: Record<string, any> = {}) {
   const { configureStore } = require('@reduxjs/toolkit');
-  return _makeCtx(configureStore({
-    reducer: _withTestActions((s: any = initialState) => s),
-    preloadedState: initialState,
-    middleware: (gdm: any) => gdm({ serializableCheck: false, immutableCheck: false }),
-  }));
+  return _makeCtx(
+    configureStore({
+      reducer: _withTestActions((s: any = initialState) => s),
+      preloadedState: initialState,
+      middleware: (gdm: any) => gdm({ serializableCheck: false, immutableCheck: false }),
+    }),
+  );
 }
 
 export function withAppReducer(
@@ -50,11 +56,13 @@ export function withAppReducer(
   preloadedState?: Record<string, any>,
 ) {
   const { configureStore } = require('@reduxjs/toolkit');
-  return _makeCtx(configureStore({
-    reducer: _withTestActions(reducer),
-    preloadedState,
-    middleware: (gdm: any) => gdm({ serializableCheck: false, immutableCheck: false }),
-  }));
+  return _makeCtx(
+    configureStore({
+      reducer: _withTestActions(reducer),
+      preloadedState,
+      middleware: (gdm: any) => gdm({ serializableCheck: false, immutableCheck: false }),
+    }),
+  );
 }
 
 interface RtkQueryApi {
@@ -90,8 +98,8 @@ export function setupApiStore(
     middleware: (gdm: any) => {
       let chain = gdm({ serializableCheck: false, immutableCheck: false });
       for (const a of apis) chain = chain.concat(a.middleware);
-      for (const mw of (options?.middleware?.concat ?? [])) chain = chain.concat(mw);
-      for (const mw of (options?.middleware?.prepend ?? [])) chain = chain.prepend(mw);
+      for (const mw of options?.middleware?.concat ?? []) chain = chain.concat(mw);
+      for (const mw of options?.middleware?.prepend ?? []) chain = chain.prepend(mw);
       return chain;
     },
   });

package/src/mock.ts

@@ -18,16 +18,13 @@ const mockRegistry: Record<string, Record<string, any>> = (globalThis as any).__
 (globalThis as any).__HT_mocks = mockRegistry;
 
 // Per-file mock scoping: __HT_file_mocks[filename][modulePath] = mock
-const fileMocks: Record<string, Record<string, any>> =
-  (globalThis as any).__HT_file_mocks || ((globalThis as any).__HT_file_mocks = {});
+const fileMocks: Record<string, Record<string, any>> = (globalThis as any).__HT_file_mocks ||
+((globalThis as any).__HT_file_mocks = {});
 
 // Track patches applied by mock() so they can be undone between files
 let mockModulePatches: { target: any; key: string; original: any }[] = [];
 
-export function mockModule(
-  modulePath: string,
-  factory: () => Record<string, any>
-): void {
+export function mockModule(modulePath: string, factory: () => Record<string, any>): void {
   const impl = factory();
   const value = typeof impl === 'function' ? impl : wrapWithSpies(impl);
 
@@ -55,7 +52,9 @@ export function mockModule(
           mockModulePatches.push({ target: globalMock, key, original: globalMock[key] });
           globalMock[key] = value[key];
         }
-      } catch { /* frozen or non-configurable */ }
+      } catch {
+        /* frozen or non-configurable */
+      }
     }
     // Also patch 'default' export if mock provides it
     if ('default' in value && 'default' in globalMock) {
@@ -68,7 +67,9 @@ export function mockModule(
               mockModulePatches.push({ target: realDefault, key, original: realDefault[key] });
               realDefault[key] = mockDefault[key];
             }
-          } catch { /* frozen */ }
+          } catch {
+            /* frozen */
+          }
         }
       }
     }
@@ -80,10 +81,13 @@ export function mockModule(
 // with the new __currentTestFile).
 export function resetMockModulePatches(): void {
   for (const { target, key, original } of mockModulePatches) {
-    try { target[key] = original; } catch { /* best effort */ }
+    try {
+      target[key] = original;
+    } catch {
+      /* best effort */
+    }
   }
   mockModulePatches = [];
-
 }
 
 function wrapWithSpies<T extends Record<string, any>>(impl: T): T {
@@ -101,7 +105,7 @@ function wrapWithSpies<T extends Record<string, any>>(impl: T): T {
 
 export function useMock<T extends Record<string, any>>(
   moduleExports: T,
-  implementation: Partial<T>
+  implementation: Partial<T>,
 ): { [K in keyof T]: T[K] extends (...args: any[]) => any ? Spy<T[K]> : T[K] } {
   const wrapped = wrapWithSpies(implementation as Record<string, any>);