@terreno/rtk 0.25.0 → 0.27.0

package/src/authSlice.test.ts

@@ -1,9 +1,11 @@
+// noExplicitAny: test mock typing
 // biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
-import {beforeEach, describe, expect, it} from "bun:test";
+import {beforeEach, describe, expect, it, mock} from "bun:test";
 import AsyncStorage from "@react-native-async-storage/async-storage";
 import {configureStore} from "@reduxjs/toolkit";
 import {createApi, fetchBaseQuery} from "@reduxjs/toolkit/query/react";
 import {renderHook} from "@testing-library/react-native";
+import {assert} from "chai";
 import React from "react";
 import {Provider} from "react-redux";
 
@@ -18,6 +20,10 @@ import {
   useSelectCurrentUserId,
   useSelectIsAuthenticating,
 } from "./authSlice";
+import type {RootState} from "./constants";
+
+// Force IsWeb=true regardless of load order with the native test files.
+mock.module("./platform", () => ({IsWeb: true}));
 
 // Create a real RTK Query API with the endpoints that generateAuthSlice expects
 const api = createApi({
@@ -41,7 +47,9 @@ const api = createApi({
 });
 
 const createTestStore = () => {
-  const {authReducer, middleware, ...rest} = generateAuthSlice(api as any);
+  const {authReducer, middleware, ...rest} = generateAuthSlice(
+    api as unknown as Parameters<typeof generateAuthSlice>[0]
+  );
 
   return {
     ...rest,
@@ -281,26 +289,30 @@ describe("generateAuthSlice", () => {
 
 describe("selectors", () => {
   it("selectCurrentUserId returns userId", () => {
-    const state = {auth: {userId: "user-123"}} as any;
-    expect(selectCurrentUserId(state)).toBe("user-123");
+    const state: RootState = {auth: {lastTokenRefreshTimestamp: null, userId: "user-123"}};
+    assert.equal(selectCurrentUserId(state), "user-123");
   });
 
   it("selectCurrentUserId returns undefined when no auth state", () => {
-    expect(selectCurrentUserId({} as any)).toBeUndefined();
+    assert.isUndefined(selectCurrentUserId({}));
   });
 
   it("selectIsAuthenticating returns isAuthenticating", () => {
-    const state = {auth: {isAuthenticating: true}} as any;
-    expect(selectIsAuthenticating(state)).toBe(true);
+    const state: RootState = {auth: {isAuthenticating: true, lastTokenRefreshTimestamp: null}};
+    assert.isTrue(selectIsAuthenticating(state));
   });
 
   it("selectIsAuthenticating defaults to false", () => {
-    expect(selectIsAuthenticating({} as any)).toBe(false);
+    assert.isFalse(selectIsAuthenticating({}));
   });
 
   it("selectLastTokenRefreshTimestamp returns timestamp", () => {
-    const state = {auth: {lastTokenRefreshTimestamp: 12345}} as any;
-    expect(selectLastTokenRefreshTimestamp(state)).toBe(12345);
+    const state: RootState = {auth: {lastTokenRefreshTimestamp: 12345}};
+    assert.equal(selectLastTokenRefreshTimestamp(state), 12345);
+  });
+
+  it("selectLastTokenRefreshTimestamp defaults to null", () => {
+    assert.isNull(selectLastTokenRefreshTimestamp({}));
   });
 });
 
@@ -321,9 +333,9 @@ describe("EmailLoginRequest type", () => {
 describe("generateProfileEndpoints", () => {
   it("builds endpoint query payloads", () => {
     const builder = {
-      mutation: (config: any) => config,
-    };
-    const endpoints = generateProfileEndpoints(builder as any, "todos");
+      mutation: (config: unknown) => config,
+    } as unknown as Parameters<typeof generateProfileEndpoints>[0];
+    const endpoints = generateProfileEndpoints(builder, "todos");
     const createEmailUserQuery = endpoints.createEmailUser.query;
     const emailLoginQuery = endpoints.emailLogin.query;
     const emailSignUpQuery = endpoints.emailSignUp.query;

package/src/authSlice.ts

@@ -66,6 +66,7 @@ export interface GoogleLoginRequest {
 }
 
 export const generateProfileEndpoints = (
+  // noExplicitAny: Generic
   // biome-ignore lint/suspicious/noExplicitAny: Generic
   builder: EndpointBuilder<BaseQueryFn<unknown, unknown, unknown>, any, string>,
   path: string
@@ -119,6 +120,7 @@ export const generateProfileEndpoints = (
   };
 };
 
+// noExplicitAny: Generic
 // biome-ignore lint/suspicious/noExplicitAny: Generic
 export const generateAuthSlice = (api: Api<any, any, any, any, any>) => {
   const authSlice = createSlice({
@@ -298,7 +300,7 @@ export const generateAuthSlice = (api: Api<any, any, any, any, any>) => {
 
 export const selectCurrentUserId = (state: RootState): string | undefined => state.auth?.userId;
 export const selectLastTokenRefreshTimestamp = (state: RootState): number | null =>
-  state.auth?.lastTokenRefreshTimestamp;
+  state.auth?.lastTokenRefreshTimestamp ?? null;
 export const selectIsAuthenticating = (state: RootState): boolean =>
   state.auth?.isAuthenticating ?? false;
 

package/src/authSliceNative.test.ts

@@ -1,5 +1,4 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
-import {afterAll, afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
 
 // Keep this mock a superset of the preload's react-native mock so that other
 // test files (e.g. useUpgradeCheck.test.ts) can still find AppState and Linking
@@ -17,7 +16,8 @@ mock.module("react-native", () => ({
 
 // Force IsWeb=false regardless of whether ./platform was already imported
 // elsewhere in the test run. `mock.module` is hoisted in bun, so this takes
-// effect before the dynamic imports below.
+// effect before the dynamic imports below. Web-path test files must set their
+// own top-of-file `IsWeb: true` guard; do not rely on afterAll restore here.
 mock.module("./platform", () => ({IsWeb: false}));
 
 const secureCalls = {
@@ -69,7 +69,7 @@ const api = createApi({
 });
 
 const createTestStore = () => {
-  const {authReducer, middleware, authSlice} = auth.generateAuthSlice(api as any);
+  const {authReducer, middleware, authSlice} = auth.generateAuthSlice(api);
   const store = configureStore({
     middleware: (getDefault) =>
       getDefault({serializableCheck: false}).concat(api.middleware, ...middleware),
@@ -111,20 +111,6 @@ describe("native listener middleware side effects", () => {
     console.error = originalError;
   });
 
-  afterAll(() => {
-    // Restore mocks to the values the rest of the suite expects.
-    mock.module("react-native", () => ({
-      Platform: {OS: "web"},
-      StyleSheet: {create: (s: unknown) => s},
-    }));
-    mock.module("./platform", () => ({IsWeb: true}));
-    mock.module("expo-secure-store", () => ({
-      deleteItemAsync: async () => {},
-      getItemAsync: async () => null,
-      setItemAsync: async () => {},
-    }));
-  });
-
   it("stores tokens in SecureStore on native login", async () => {
     const {store} = createTestStore();
     store.dispatch({

package/src/betterAuthClient.ts

@@ -96,8 +96,7 @@ export const createBetterAuthClient = (config: BetterAuthClientConfig) => {
     plugins: [
       expoClient({
         scheme: config.scheme,
-        // biome-ignore lint/suspicious/noExplicitAny: Better Auth storage type is flexible
-        storage: storage as any,
+        storage: storage as NonNullable<Parameters<typeof expoClient>[0]>["storage"],
         storagePrefix: config.storagePrefix ?? "terreno",
       }),
     ],

package/src/betterAuthSlice.test.ts

@@ -1,3 +1,4 @@
+// noExplicitAny: test mock typing
 // biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it, mock} from "bun:test";
 import {configureStore} from "@reduxjs/toolkit";

package/src/constants.ts

@@ -1,7 +1,12 @@
 import Constants from "expo-constants";
 
-// biome-ignore lint/suspicious/noExplicitAny: RootState is hard to type without becoming circular.
-export type RootState = any;
+export interface RootState {
+  auth?: {
+    isAuthenticating?: boolean;
+    lastTokenRefreshTimestamp: number | null;
+    userId?: string;
+  };
+}
 export const LOGOUT_ACTION_TYPE = "auth/logout";
 export const TOKEN_REFRESHED_SUCCESS = "auth/tokenRefreshedSuccess";
 

package/src/emptyApi.ts

@@ -207,8 +207,7 @@ export const getBaseQuery = (
         return result;
       }
     },
-    // biome-ignore lint/suspicious/noExplicitAny: Weird typing from rtk query
-  })(args, api, extraOptions as any);
+  })(args, api, extraOptions as Parameters<ReturnType<typeof fetchBaseQuery>>[2]);
 };
 
 export const staggeredBaseQuery = retry(
@@ -355,8 +354,10 @@ export const emptySplitApi = createApi({
         url: "/version-check",
       }),
     }),
-    // biome-ignore lint/suspicious/noExplicitAny: Generic
-    ...generateProfileEndpoints(builder as any, "users"), // using 'users' here since it is highly intertwined with Users
+    ...generateProfileEndpoints(
+      builder as unknown as Parameters<typeof generateProfileEndpoints>[0],
+      "users"
+    ), // using 'users' here since it is highly intertwined with Users
   }),
   reducerPath: "terreno-rtk",
 });

package/src/isolated/constants.isolated.ts

@@ -0,0 +1,118 @@
+/**
+ * In-process isolated coverage for constants.ts module-load debug paths.
+ *
+ * The base test suite loads constants.ts once with debug flags disabled, so the
+ * enable-time branches (AUTH_DEBUG / WEBSOCKETS_DEBUG log lines and the Expo
+ * tunnel warning) never execute under coverage. Here we re-mock expo-constants
+ * with every flag enabled and re-import the module through a cache-busting query
+ * so its top-level runs again while coverage instrumentation is active.
+ */
+import {beforeEach, describe, it, mock} from "bun:test";
+import {assert} from "chai";
+
+interface ConstantsModule {
+  AUTH_DEBUG: boolean;
+  logAuth: (...args: string[]) => void;
+  logSocket: (
+    user?: {featureFlags?: {debugWebsockets?: {enabled?: boolean}}} | boolean,
+    ...args: string[]
+  ) => void;
+  isWebsocketsDebugEnabled: () => boolean;
+}
+
+const loadWithEnabledFlags = async (): Promise<{
+  module: ConstantsModule;
+  debugCalls: unknown[][];
+  errorCalls: unknown[][];
+  infoCalls: unknown[][];
+}> => {
+  mock.module("expo-constants", () => ({
+    default: {
+      expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}},
+      expoGoConfig: {debuggerHost: "abc.exp.direct"},
+    },
+  }));
+
+  const debugCalls: unknown[][] = [];
+  const errorCalls: unknown[][] = [];
+  const infoCalls: unknown[][] = [];
+  const originalDebug = console.debug;
+  const originalError = console.error;
+  const originalInfo = console.info;
+  console.debug = (...args: unknown[]): void => {
+    debugCalls.push(args);
+  };
+  console.error = (...args: unknown[]): void => {
+    errorCalls.push(args);
+  };
+  console.info = (...args: unknown[]): void => {
+    infoCalls.push(args);
+  };
+
+  try {
+    const constantsUrl = new URL("../constants.ts", import.meta.url).href;
+    const module = (await import(`${constantsUrl}?enabledFlags`)) as ConstantsModule;
+    return {debugCalls, errorCalls, infoCalls, module};
+  } finally {
+    console.debug = originalDebug;
+    console.error = originalError;
+    console.info = originalInfo;
+  }
+};
+
+describe("constants module-load debug paths", () => {
+  beforeEach(() => {
+    mock.restore();
+  });
+
+  it("logs debug lines and the tunnel warning when every flag is enabled", async () => {
+    const {module, debugCalls, errorCalls} = await loadWithEnabledFlags();
+
+    assert.isTrue(module.AUTH_DEBUG);
+    assert.isTrue(module.isWebsocketsDebugEnabled());
+    assert.isTrue(
+      debugCalls.some((args) =>
+        args.some((value) => String(value).includes("AUTH_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      debugCalls.some((args) =>
+        args.some((value) => String(value).includes("WEBSOCKETS_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      errorCalls.some((args) =>
+        args.some((value) => String(value).includes("Expo Tunnel is not currently"))
+      )
+    );
+  });
+
+  it("routes logAuth and logSocket through console when flags are enabled", async () => {
+    const {module} = await loadWithEnabledFlags();
+
+    const debugCalls: unknown[][] = [];
+    const infoCalls: unknown[][] = [];
+    const originalDebug = console.debug;
+    const originalInfo = console.info;
+    console.debug = (...args: unknown[]): void => {
+      debugCalls.push(args);
+    };
+    console.info = (...args: unknown[]): void => {
+      infoCalls.push(args);
+    };
+    try {
+      module.logAuth("auth message");
+      module.logSocket(undefined, "socket message");
+    } finally {
+      console.debug = originalDebug;
+      console.info = originalInfo;
+    }
+
+    assert.isTrue(
+      debugCalls.some((args) => args.some((value) => String(value).includes("auth message")))
+    );
+    assert.isTrue(
+      infoCalls.some((args) => args[0] === "[websocket]" && args[1] === "socket message")
+    );
+  });
+});

package/src/isolated/constants.test.ts

@@ -1,92 +1,95 @@
 /**
  * Isolated tests for constants.ts paths that require mock.module.
  *
- * These live in isolated/ so that mock.module calls do not interfere
- * with coverage tracking in the main constants.test.ts file.
+ * The module is loaded in a subprocess so mock.module does not replace
+ * expo-constants for the rest of the package test process.
  */
-import {describe, expect, it, mock} from "bun:test";
+import {describe, it} from "bun:test";
+import {assert} from "chai";
+
+interface ConstantsModuleResult {
+  authDebug: boolean;
+  debugCalls: unknown[][];
+  errorCalls: unknown[][];
+  infoCalls: unknown[][];
+}
+
+const runConstantsModule = async (
+  expoConstants: Record<string, unknown>
+): Promise<ConstantsModuleResult> => {
+  const constantsUrl = new URL("../constants.ts", import.meta.url).href;
+  const script = `
+    import {mock} from "bun:test";
+    const output = console.log.bind(console);
+    const debugCalls = [];
+    const errorCalls = [];
+    const infoCalls = [];
+    console.debug = (...args) => debugCalls.push(args);
+    console.error = (...args) => errorCalls.push(args);
+    console.info = (...args) => infoCalls.push(args);
+    mock.module("expo-constants", () => ({default: ${JSON.stringify(expoConstants)}}));
+    const loaded = await import(${JSON.stringify(constantsUrl)});
+    loaded.logAuth("hello");
+    loaded.logSocket(undefined, "ws on");
+    output(JSON.stringify({
+      authDebug: loaded.AUTH_DEBUG,
+      debugCalls,
+      errorCalls,
+      infoCalls,
+    }));
+  `;
+  const child = Bun.spawn([process.execPath, "-e", script], {
+    cwd: import.meta.dir,
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+
+  assert.equal(exitCode, 0, stderr);
+  return JSON.parse(stdout.trim()) as ConstantsModuleResult;
+};
 
 describe("expo tunnel warning", () => {
   it("warns when expoGoConfig.debuggerHost contains exp.direct", async () => {
-    const errorCalls: unknown[][] = [];
-    const originalError = console.error;
-    console.error = (...args: unknown[]): void => {
-      errorCalls.push(args);
-    };
-    mock.module("expo-constants", () => ({
-      default: {
-        expoConfig: {extra: {}},
-        expoGoConfig: {debuggerHost: "abc.exp.direct"},
-      },
-    }));
-    try {
-      const testId = `${Date.now()}-${Math.random()}`;
-      await import(`../constants?case=${testId}`);
-      const warning = errorCalls.find((args) =>
-        args.some((v) => typeof v === "string" && v.includes("Expo Tunnel is not currently"))
-      );
-      expect(warning).toBeDefined();
-    } finally {
-      console.error = originalError;
-      mock.module("expo-constants", () => ({default: {expoConfig: {extra: {}}}}));
-    }
+    const result = await runConstantsModule({
+      expoConfig: {extra: {}},
+      expoGoConfig: {debuggerHost: "abc.exp.direct"},
+    });
+
+    assert.isTrue(
+      result.errorCalls.some((args) =>
+        args.some((value) => String(value).includes("Expo Tunnel is not currently"))
+      )
+    );
   });
 });
 
 describe("AUTH_DEBUG enabled path", () => {
-  it("logs debug messages from logAuth when AUTH_DEBUG is true on module load", async () => {
-    const debugCalls: unknown[][] = [];
-    const infoCalls: unknown[][] = [];
-    const originalDebug = console.debug;
-    const originalInfo = console.info;
-    console.debug = (...args: unknown[]): void => {
-      debugCalls.push(args);
-    };
-    console.info = (...args: unknown[]): void => {
-      infoCalls.push(args);
-    };
-    mock.module("expo-constants", () => ({
-      default: {expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}}},
-    }));
-    try {
-      const testId = `${Date.now()}-${Math.random()}`;
-      const loaded = (await import(`../constants?case=${testId}`)) as typeof import("../constants");
-      expect(loaded.AUTH_DEBUG).toBe(true);
-      const preLength = debugCalls.length;
-      loaded.logAuth("hello");
-      expect(debugCalls.length).toBe(preLength + 1);
-      loaded.logSocket(undefined, "ws on");
-      expect(infoCalls.some((args) => args[0] === "[websocket]" && args[1] === "ws on")).toBe(true);
-    } finally {
-      console.debug = originalDebug;
-      console.info = originalInfo;
-      mock.module("expo-constants", () => ({default: {expoConfig: {extra: {}}}}));
-    }
-  });
+  it("logs auth and websocket debug messages when enabled", async () => {
+    const result = await runConstantsModule({
+      expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}},
+    });
 
-  it("emits AUTH_DEBUG enabled and WEBSOCKETS_DEBUG enabled messages on module load", async () => {
-    const debugCalls: unknown[][] = [];
-    const originalDebug = console.debug;
-    console.debug = (...args: unknown[]): void => {
-      debugCalls.push(args);
-    };
-    mock.module("expo-constants", () => ({
-      default: {expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}}},
-    }));
-    try {
-      const testId = `${Date.now()}-${Math.random()}`;
-      await import(`../constants?debug=${testId}`);
-      const authMsg = debugCalls.find((args) =>
-        args.some((v) => typeof v === "string" && v.includes("AUTH_DEBUG is enabled"))
-      );
-      const wsMsg = debugCalls.find((args) =>
-        args.some((v) => typeof v === "string" && v.includes("WEBSOCKETS_DEBUG is enabled"))
-      );
-      expect(authMsg).toBeDefined();
-      expect(wsMsg).toBeDefined();
-    } finally {
-      console.debug = originalDebug;
-      mock.module("expo-constants", () => ({default: {expoConfig: {extra: {}}}}));
-    }
+    assert.isTrue(result.authDebug);
+    assert.isTrue(
+      result.debugCalls.some((args) =>
+        args.some((value) => String(value).includes("AUTH_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      result.debugCalls.some((args) =>
+        args.some((value) => String(value).includes("WEBSOCKETS_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      result.debugCalls.some((args) => args.some((value) => String(value).includes("hello")))
+    );
+    assert.isTrue(
+      result.infoCalls.some((args) => args[0] === "[websocket]" && args[1] === "ws on")
+    );
   });
 });

package/src/isolated/offlineMiddleware.isolated.ts

@@ -89,8 +89,7 @@ const api = createApi({
 
 const createTestStore = (endpoints = ["postTodos", "patchTodosById", "deleteTodosById"]) => {
   const offline = createOfflineMiddleware({
-    // biome-ignore lint/suspicious/noExplicitAny: Generic API type is intentionally broad.
-    api: api as any,
+    api: api as unknown as Parameters<typeof createOfflineMiddleware>[0]["api"],
     endpoints,
   });
 

package/src/isolated/offlineMiddleware.native.isolated.ts

@@ -45,8 +45,7 @@ const api = createApi({
 
 const createNativeStore = () => {
   const offline = createOfflineMiddleware({
-    // biome-ignore lint/suspicious/noExplicitAny: Generic API type is intentionally broad.
-    api: api as any,
+    api: api as unknown as Parameters<typeof createOfflineMiddleware>[0]["api"],
     endpoints: ["patchTodosById"],
   });
 

package/src/isolated/useUpgradeCheck.mobile.isolated.ts

@@ -195,6 +195,66 @@ describe("useUpgradeCheck (mobile)", () => {
     });
   });
 
+  describe("recheckOnForeground", () => {
+    it("re-checks when the app returns to the foreground", async () => {
+      const {result} = renderHook(() => useUpgradeCheck({recheckOnForeground: true}));
+
+      await act(async () => {
+        await flushPromises();
+      });
+
+      expect(result.current).toBeDefined();
+      expect(appStateListeners.length).toBeGreaterThan(0);
+      const initialCalls = mockTrigger.mock.calls.length;
+
+      await act(async () => {
+        // First go to the background, then return to the foreground: the
+        // background transition primes appState.current so the subsequent
+        // active transition satisfies the wasBackground && isNowActive guard.
+        for (const listener of appStateListeners) {
+          listener("background");
+        }
+        for (const listener of appStateListeners) {
+          listener("active");
+        }
+        await flushPromises();
+      });
+
+      expect(mockTrigger.mock.calls.length).toBeGreaterThan(initialCalls);
+    });
+
+    it("does not re-check when the app stays inactive", async () => {
+      renderHook(() => useUpgradeCheck({recheckOnForeground: true}));
+
+      await act(async () => {
+        await flushPromises();
+      });
+
+      const initialCalls = mockTrigger.mock.calls.length;
+
+      await act(async () => {
+        for (const listener of appStateListeners) {
+          listener("inactive");
+        }
+        await flushPromises();
+      });
+
+      expect(mockTrigger.mock.calls.length).toBe(initialCalls);
+    });
+
+    it("removes the AppState subscription on unmount", async () => {
+      const {unmount} = renderHook(() => useUpgradeCheck({recheckOnForeground: true}));
+
+      await act(async () => {
+        await flushPromises();
+      });
+
+      mockRemove.mockClear();
+      unmount();
+      expect(mockRemove).toHaveBeenCalled();
+    });
+  });
+
   describe("canUpdate", () => {
     it("is false on mobile when updateUrl is not set", () => {
       const {result} = renderHook(() => useUpgradeCheck());

package/src/mongooseSlice.test.ts

@@ -1,4 +1,3 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {describe, expect, it} from "bun:test";
 
 import {type ListResponse, populateId} from "./mongooseSlice";
@@ -39,7 +38,7 @@ describe("populateId", () => {
 
   it("handles sparse arrays without throwing", () => {
     const sparse: ListResponse<{_id: string}> = {
-      data: [undefined as any, {_id: "found"}],
+      data: [undefined as unknown as {_id: string}, {_id: "found"}],
     };
     expect(populateId("found", sparse)).toEqual({_id: "found"});
   });

package/src/offlineGate.ts

@@ -13,8 +13,7 @@ export const configureOfflineMutationEndpoints = (endpoints: string[]): void =>
  */
 export const shouldDeferOfflineMutation = (
   endpointName: string,
-  // biome-ignore lint/suspicious/noExplicitAny: Redux getState is app-specific
-  getState: () => any
+  getState: () => unknown
 ): boolean => {
   if (!offlineMutationEndpoints.has(endpointName)) {
     return false;

package/src/offlineMiddleware.test.ts

@@ -1,4 +1,4 @@
-import {describe, expect, it} from "bun:test";
+import {describe, expect, it, mock} from "bun:test";
 import {configureStore, type UnknownAction} from "@reduxjs/toolkit";
 import type {Api} from "@reduxjs/toolkit/query/react";
 
@@ -10,6 +10,9 @@ import {
 } from "./offlineMiddleware";
 import {type OfflineState, type QueuedMutation, selectOfflineQueue} from "./offlineSlice";
 
+// Force IsWeb=true regardless of load order with the native test files.
+mock.module("./platform", () => ({IsWeb: true}));
+
 interface QueryEntry {
   data?: {data: Record<string, unknown>[]};
   originalArgs: unknown;
@@ -47,6 +50,7 @@ const initialTestApiState: TestApiState = {
 
 const testApiReducer = (state: TestApiState = initialTestApiState): TestApiState => state;
 
+// noExplicitAny: Test double covers only fields used by offline middleware.
 // biome-ignore lint/suspicious/noExplicitAny: Test double covers only fields used by offline middleware.
 const createTestApi = (): Api<any, any, any, any> => {
   return {
@@ -66,6 +70,7 @@ const createTestApi = (): Api<any, any, any, any> => {
       invalidateTags: () => ({type: "testApi/invalidateTags"}),
       updateQueryData: () => ({type: "testApi/updateQueryData"}),
     },
+    // noExplicitAny: Test double covers only fields used by offline middleware.
     // biome-ignore lint/suspicious/noExplicitAny: Test double covers only fields used by offline middleware.
   } as unknown as Api<any, any, any, any>;
 };