@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/stealth/StealthScripts.comprehensive.test.js

@@ -0,0 +1,306 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StealthScripts } from '../../../src/modules/stealth/StealthScripts.js';
+function createPageMock() {
+    return {
+        evaluateOnNewDocument: vi.fn(async () => undefined),
+        setUserAgent: vi.fn(async () => undefined),
+    };
+}
+function resetInjectedPages() {
+    StealthScripts.injectedPages = new WeakSet();
+}
+describe('StealthScripts – comprehensive coverage', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        resetInjectedPages();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('injectAll', () => {
+        it('calls all ten stealth methods exactly once', async () => {
+            const spyNames = [
+                'hideWebDriver',
+                'mockChrome',
+                'mockPlugins',
+                'fixPermissions',
+                'mockCanvas',
+                'mockWebGL',
+                'fixLanguages',
+                'mockBattery',
+                'fixMediaDevices',
+                'mockNotifications',
+            ];
+            const spies = spyNames.map((name) => vi.spyOn(StealthScripts, name).mockResolvedValue(undefined));
+            const page = createPageMock();
+            await StealthScripts.injectAll(page);
+            for (const spy of spies) {
+                expect(spy).toHaveBeenCalledOnce();
+                expect(spy).toHaveBeenCalledWith(page);
+            }
+        });
+        it('records the page in the WeakSet so a second call is a no-op', async () => {
+            const spyNames = [
+                'hideWebDriver',
+                'mockChrome',
+                'mockPlugins',
+                'fixPermissions',
+                'mockCanvas',
+                'mockWebGL',
+                'fixLanguages',
+                'mockBattery',
+                'fixMediaDevices',
+                'mockNotifications',
+            ];
+            const spies = spyNames.map((name) => vi.spyOn(StealthScripts, name).mockResolvedValue(undefined));
+            const page = createPageMock();
+            await StealthScripts.injectAll(page);
+            await StealthScripts.injectAll(page);
+            for (const spy of spies) {
+                expect(spy).toHaveBeenCalledTimes(1);
+            }
+        });
+        it('treats distinct page objects independently', async () => {
+            const spy = vi
+                .spyOn(StealthScripts, 'hideWebDriver')
+                .mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockChrome').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockPlugins').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixPermissions').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockCanvas').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockWebGL').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixLanguages').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockBattery').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixMediaDevices').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockNotifications').mockResolvedValue(undefined);
+            const p1 = createPageMock();
+            const p2 = createPageMock();
+            const p3 = createPageMock();
+            await StealthScripts.injectAll(p1);
+            await StealthScripts.injectAll(p2);
+            await StealthScripts.injectAll(p3);
+            expect(spy).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('hideWebDriver', () => {
+        it('injects a script that makes navigator.webdriver undefined', async () => {
+            const page = createPageMock();
+            await StealthScripts.hideWebDriver(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('mockChrome', () => {
+        it('injects a script that sets window.chrome', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockChrome(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('mockPlugins', () => {
+        it('injects a script to override navigator.plugins', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockPlugins(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('fixPermissions', () => {
+        it('injects a script that patches permissions.query', async () => {
+            const page = createPageMock();
+            await StealthScripts.fixPermissions(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('mockCanvas', () => {
+        it('injects a script that patches canvas fingerprinting', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockCanvas(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('mockWebGL', () => {
+        it('injects a script that spoofs WebGL vendor/renderer', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockWebGL(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('fixLanguages', () => {
+        it('injects a script that sets navigator.language and languages', async () => {
+            const page = createPageMock();
+            await StealthScripts.fixLanguages(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('mockBattery', () => {
+        it('injects a script that patches getBattery', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockBattery(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('fixMediaDevices', () => {
+        it('injects a script that patches enumerateDevices', async () => {
+            const page = createPageMock();
+            await StealthScripts.fixMediaDevices(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('mockNotifications', () => {
+        it('injects a script that patches Notification.permission', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockNotifications(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+    });
+    describe('setRealisticUserAgent', () => {
+        it('windows: sets Windows user-agent and Win32 platform', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, 'windows');
+            expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Windows NT 10.0'));
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), 'Win32');
+        });
+        it('mac: sets Mac user-agent and MacIntel platform', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, 'mac');
+            expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Macintosh'));
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), 'MacIntel');
+        });
+        it('linux: sets Linux user-agent and Linux x86_64 platform', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, 'linux');
+            expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Linux x86_64'));
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), 'Linux x86_64');
+        });
+        it('defaults to windows when no platform argument is given', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page);
+            expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Windows NT 10.0'));
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), 'Win32');
+        });
+        it('user-agent strings include Chrome/120', async () => {
+            for (const platform of ['windows', 'mac', 'linux']) {
+                const page = createPageMock();
+                await StealthScripts.setRealisticUserAgent(page, platform);
+                const ua = page.setUserAgent.mock.calls[0][0];
+                expect(ua).toContain('Chrome/120.0.0.0');
+                expect(ua).toContain('Safari/537.36');
+            }
+        });
+    });
+    describe('getRecommendedLaunchArgs', () => {
+        it('returns an array of strings', () => {
+            const args = StealthScripts.getRecommendedLaunchArgs();
+            expect(Array.isArray(args)).toBe(true);
+            for (const arg of args) {
+                expect(typeof arg).toBe('string');
+                expect(arg.startsWith('--')).toBe(true);
+            }
+        });
+        it('contains all expected critical flags', () => {
+            const args = StealthScripts.getRecommendedLaunchArgs();
+            const expected = [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-blink-features=AutomationControlled',
+                '--disable-dev-shm-usage',
+                '--disable-accelerated-2d-canvas',
+                '--no-first-run',
+                '--no-zygote',
+                '--disable-gpu',
+                '--disable-web-security',
+                '--disable-features=IsolateOrigins,site-per-process',
+                '--window-size=1920,1080',
+                '--disable-infobars',
+                '--disable-extensions',
+                '--disable-default-apps',
+                '--disable-sync',
+                '--metrics-recording-only',
+                '--mute-audio',
+                '--no-default-browser-check',
+                '--disable-background-timer-throttling',
+                '--disable-backgrounding-occluded-windows',
+                '--disable-renderer-backgrounding',
+            ];
+            for (const flag of expected) {
+                expect(args).toContain(flag);
+            }
+        });
+        it('has exactly 21 entries with no duplicates', () => {
+            const args = StealthScripts.getRecommendedLaunchArgs();
+            expect(args.length).toBe(21);
+            expect(new Set(args).size).toBe(args.length);
+        });
+        it('returns a fresh array every call (no shared reference)', () => {
+            const a = StealthScripts.getRecommendedLaunchArgs();
+            const b = StealthScripts.getRecommendedLaunchArgs();
+            expect(a).not.toBe(b);
+            expect(a).toEqual(b);
+        });
+    });
+    describe('concurrent injectAll', () => {
+        it('handles parallel injectAll on different pages without interference', async () => {
+            const spy = vi
+                .spyOn(StealthScripts, 'hideWebDriver')
+                .mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockChrome').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockPlugins').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixPermissions').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockCanvas').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockWebGL').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixLanguages').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockBattery').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixMediaDevices').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockNotifications').mockResolvedValue(undefined);
+            const pages = Array.from({ length: 5 }, () => createPageMock());
+            await Promise.all(pages.map((p) => StealthScripts.injectAll(p)));
+            expect(spy).toHaveBeenCalledTimes(5);
+        });
+    });
+    describe('method isolation', () => {
+        it('each stealth method only calls evaluateOnNewDocument once', async () => {
+            const methods = [
+                StealthScripts.hideWebDriver,
+                StealthScripts.mockChrome,
+                StealthScripts.mockPlugins,
+                StealthScripts.fixPermissions,
+                StealthScripts.mockCanvas,
+                StealthScripts.mockWebGL,
+                StealthScripts.fixLanguages,
+                StealthScripts.mockBattery,
+                StealthScripts.fixMediaDevices,
+                StealthScripts.mockNotifications,
+            ];
+            for (const method of methods) {
+                const page = createPageMock();
+                await method(page);
+                expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            }
+        });
+        it('setRealisticUserAgent calls both setUserAgent and evaluateOnNewDocument', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, 'windows');
+            expect(page.setUserAgent).toHaveBeenCalledTimes(1);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/tests/modules/stealth/StealthScripts.injected-scripts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/modules/stealth/StealthScripts.injected-scripts.test.js

@@ -0,0 +1,220 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { StealthScripts } from "../../../src/modules/stealth/StealthScripts.js";
+function createPageMock() {
+    return {
+        evaluateOnNewDocument: vi.fn(async (_fn, ..._args) => undefined),
+        setUserAgent: vi.fn(async () => undefined),
+    };
+}
+function resetInjectedPages() {
+    StealthScripts.injectedPages = new WeakSet();
+}
+function getInjectedFn(page) {
+    const call = page.evaluateOnNewDocument.mock.calls[0];
+    return { fn: call[0], extraArgs: call.slice(1) };
+}
+describe("StealthScripts injected browser-side scripts", () => {
+    beforeEach(() => { vi.restoreAllMocks(); resetInjectedPages(); });
+    afterEach(() => { vi.restoreAllMocks(); });
+    describe("hideWebDriver injected script", () => {
+        it("patches Object.getOwnPropertyNames to filter webdriver", async () => {
+            const page = createPageMock();
+            await StealthScripts.hideWebDriver(page);
+            const { fn } = getInjectedFn(page);
+            const orig = Object.getOwnPropertyNames;
+            expect(() => fn()).not.toThrow();
+            const props = Object.getOwnPropertyNames({ webdriver: true, foo: "bar" });
+            expect(props).not.toContain("webdriver");
+            expect(props).toContain("foo");
+            Object.getOwnPropertyNames = orig;
+        });
+    });
+    describe("mockChrome injected script", () => {
+        it("sets window.chrome with runtime loadTimes csi", async () => {
+            const page = createPageMock();
+            await StealthScripts.mockChrome(page);
+            const { fn } = getInjectedFn(page);
+            const ow = globalThis.window;
+            globalThis.window = {};
+            try {
+                fn();
+                const win = globalThis.window;
+                expect(win.chrome).toBeDefined();
+                expect(typeof win.chrome.runtime.connect).toBe("function");
+                expect(typeof win.chrome.runtime.sendMessage).toBe("function");
+                expect(typeof win.chrome.runtime.onMessage.addListener).toBe("function");
+                const lt = win.chrome.loadTimes();
+                expect(lt).toHaveProperty("connectionInfo", "http/1.1");
+                expect(lt).toHaveProperty("navigationType", "Other");
+                expect(lt).toHaveProperty("wasAlternateProtocolAvailable", false);
+                const cs = win.chrome.csi();
+                expect(cs).toHaveProperty("tran", 15);
+                expect(typeof cs.onloadT).toBe("number");
+                expect(win.chrome.app).toEqual({});
+            }
+            finally {
+                if (ow === undefined)
+                    delete globalThis.window;
+                else
+                    globalThis.window = ow;
+            }
+        });
+    });
+    describe("mockPlugins injected script", () => {
+        it("overrides navigator.plugins with 3 entries", async () => {
+            const page = createPageMock();
+            await StealthScripts.mockPlugins(page);
+            getInjectedFn(page).fn();
+            const d = Object.getOwnPropertyDescriptor(navigator, "plugins");
+            if (d?.get) {
+                const plugins = d.get();
+                expect(plugins).toHaveLength(3);
+                expect(plugins[0].name).toBe("Chrome PDF Plugin");
+                expect(plugins[1].name).toBe("Chrome PDF Viewer");
+                expect(plugins[2].name).toBe("Native Client");
+            }
+        });
+    });
+    describe("fixLanguages injected script", () => {
+        it("overrides navigator.language and languages", async () => {
+            const page = createPageMock();
+            await StealthScripts.fixLanguages(page);
+            getInjectedFn(page).fn();
+            const ld = Object.getOwnPropertyDescriptor(navigator, "language");
+            if (ld?.get)
+                expect(ld.get()).toBe("en-US");
+            const lsd = Object.getOwnPropertyDescriptor(navigator, "languages");
+            if (lsd?.get)
+                expect(lsd.get()).toEqual(["en-US", "en"]);
+        });
+    });
+    describe("mockBattery injected script", () => {
+        it("does not throw when getBattery does not exist", async () => {
+            const page = createPageMock();
+            await StealthScripts.mockBattery(page);
+            expect(() => getInjectedFn(page).fn()).not.toThrow();
+        });
+        it("wraps getBattery when it exists", async () => {
+            const page = createPageMock();
+            await StealthScripts.mockBattery(page);
+            const { fn } = getInjectedFn(page);
+            const orig = navigator.getBattery;
+            navigator.getBattery = () => Promise.resolve({ charging: false, chargingTime: 100, dischargingTime: 500, level: 0.5 });
+            fn();
+            const bat = await navigator.getBattery();
+            expect(bat).toBeDefined();
+            if (orig)
+                navigator.getBattery = orig;
+            else
+                delete navigator.getBattery;
+        });
+    });
+    describe("mockNotifications injected script", () => {
+        it("patches when Notification exists in window", async () => {
+            const page = createPageMock();
+            await StealthScripts.mockNotifications(page);
+            const { fn } = getInjectedFn(page);
+            const ow = globalThis.window;
+            const oNotif = globalThis.Notification;
+            const NotifCtor = function N() { };
+            globalThis.window = { Notification: NotifCtor };
+            globalThis.Notification = NotifCtor;
+            try {
+                expect(() => fn()).not.toThrow();
+            }
+            finally {
+                if (ow === undefined)
+                    delete globalThis.window;
+                else
+                    globalThis.window = ow;
+                if (oNotif === undefined)
+                    delete globalThis.Notification;
+                else
+                    globalThis.Notification = oNotif;
+            }
+        });
+        it("does nothing when Notification not in window", async () => {
+            const page = createPageMock();
+            await StealthScripts.mockNotifications(page);
+            const { fn } = getInjectedFn(page);
+            const ow = globalThis.window;
+            globalThis.window = {};
+            try {
+                expect(() => fn()).not.toThrow();
+            }
+            finally {
+                if (ow === undefined)
+                    delete globalThis.window;
+                else
+                    globalThis.window = ow;
+            }
+        });
+    });
+    describe("setRealisticUserAgent injected script", () => {
+        it("overrides navigator properties for windows", async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, "windows");
+            const { fn, extraArgs } = getInjectedFn(page);
+            expect(extraArgs[0]).toBe("Win32");
+            fn(extraArgs[0]);
+            const pd = Object.getOwnPropertyDescriptor(navigator, "platform");
+            if (pd?.get)
+                expect(pd.get()).toBe("Win32");
+            const vd = Object.getOwnPropertyDescriptor(navigator, "vendor");
+            if (vd?.get)
+                expect(vd.get()).toBe("Google Inc.");
+            const cd = Object.getOwnPropertyDescriptor(navigator, "hardwareConcurrency");
+            if (cd?.get)
+                expect(cd.get()).toBe(8);
+            const md = Object.getOwnPropertyDescriptor(navigator, "deviceMemory");
+            if (md?.get)
+                expect(md.get()).toBe(8);
+        });
+        it("sets MacIntel for mac", async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, "mac");
+            expect(getInjectedFn(page).extraArgs[0]).toBe("MacIntel");
+        });
+        it("sets Linux x86_64 for linux", async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, "linux");
+            expect(getInjectedFn(page).extraArgs[0]).toBe("Linux x86_64");
+        });
+    });
+    describe("injectAll edge cases", () => {
+        it("marks page and skips on re-call", async () => {
+            const methods = ["hideWebDriver", "mockChrome", "mockPlugins", "fixPermissions", "mockCanvas", "mockWebGL", "fixLanguages", "mockBattery", "fixMediaDevices", "mockNotifications"];
+            const spies = methods.map(m => vi.spyOn(StealthScripts, m).mockResolvedValue(undefined));
+            const page = createPageMock();
+            await StealthScripts.injectAll(page);
+            for (const s of spies)
+                expect(s).toHaveBeenCalledTimes(1);
+            await StealthScripts.injectAll(page);
+            for (const s of spies)
+                expect(s).toHaveBeenCalledTimes(1);
+        });
+        it("allows injection after WeakSet reset", async () => {
+            const spy = vi.spyOn(StealthScripts, "hideWebDriver").mockResolvedValue(undefined);
+            ["mockChrome", "mockPlugins", "fixPermissions", "mockCanvas", "mockWebGL", "fixLanguages", "mockBattery", "fixMediaDevices", "mockNotifications"].forEach(m => vi.spyOn(StealthScripts, m).mockResolvedValue(undefined));
+            const page = createPageMock();
+            await StealthScripts.injectAll(page);
+            expect(spy).toHaveBeenCalledTimes(1);
+            resetInjectedPages();
+            await StealthScripts.injectAll(page);
+            expect(spy).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("simple checks", () => {
+        it("fixPermissions is a valid function", async () => { const p = createPageMock(); await StealthScripts.fixPermissions(p); expect(typeof getInjectedFn(p).fn).toBe("function"); });
+        it("mockCanvas is a valid function", async () => { const p = createPageMock(); await StealthScripts.mockCanvas(p); expect(typeof getInjectedFn(p).fn).toBe("function"); });
+        it("mockWebGL is a valid function", async () => { const p = createPageMock(); await StealthScripts.mockWebGL(p); expect(typeof getInjectedFn(p).fn).toBe("function"); });
+        it("fixMediaDevices does not throw", async () => { const p = createPageMock(); await StealthScripts.fixMediaDevices(p); expect(() => getInjectedFn(p).fn()).not.toThrow(); });
+        it("getRecommendedLaunchArgs includes critical flags", () => {
+            const args = StealthScripts.getRecommendedLaunchArgs();
+            expect(args).toContain("--disable-blink-features=AutomationControlled");
+            expect(args).toContain("--no-first-run");
+            for (const a of args)
+                expect(a.startsWith("--")).toBe(true);
+        });
+    });
+});

package/dist/tests/native/NativeMemoryManager.availability.extended.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/native/NativeMemoryManager.availability.extended.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const state = vi.hoisted(() => ({
+    isKoffiAvailable: vi.fn(),
+    isWindows: vi.fn(),
+    execAsync: vi.fn(),
+}));
+vi.mock('@native/Win32API', () => ({
+    isKoffiAvailable: state.isKoffiAvailable,
+    isWindows: state.isWindows,
+}));
+import { checkNativeMemoryAvailability } from '../../src/native/NativeMemoryManager.availability.js';
+describe('NativeMemoryManager.availability', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns unavailable when not on Windows', async () => {
+        state.isWindows.mockReturnValue(false);
+        const result = await checkNativeMemoryAvailability(state.execAsync);
+        expect(result.available).toBe(false);
+        expect(result.reason).toContain('only supported on Windows');
+        expect(state.execAsync).not.toHaveBeenCalled();
+    });
+    it('returns unavailable when koffi is not available', async () => {
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(false);
+        const result = await checkNativeMemoryAvailability(state.execAsync);
+        expect(result.available).toBe(false);
+        expect(result.reason).toContain('koffi library not available');
+    });
+    it('returns available when running as admin on Windows', async () => {
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(true);
+        state.execAsync.mockResolvedValue({ stdout: 'True\n', stderr: '' });
+        const result = await checkNativeMemoryAvailability(state.execAsync);
+        expect(result.available).toBe(true);
+        expect(result.reason).toBeUndefined();
+    });
+    it('returns unavailable when not running as admin', async () => {
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(true);
+        state.execAsync.mockResolvedValue({ stdout: 'False\n', stderr: '' });
+        const result = await checkNativeMemoryAvailability(state.execAsync);
+        expect(result.available).toBe(false);
+        expect(result.reason).toContain('Administrator privileges');
+    });
+    it('returns unavailable when admin check throws', async () => {
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(true);
+        state.execAsync.mockRejectedValue(new Error('powershell failed'));
+        const result = await checkNativeMemoryAvailability(state.execAsync);
+        expect(result.available).toBe(false);
+        expect(result.reason).toContain('Failed to check Administrator privileges');
+    });
+    it('passes the execAsync function as the check command runner', async () => {
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(true);
+        state.execAsync.mockResolvedValue({ stdout: 'True\n', stderr: '' });
+        await checkNativeMemoryAvailability(state.execAsync);
+        expect(state.execAsync).toHaveBeenCalledWith(expect.stringContaining('IsInRole'), expect.objectContaining({ timeout: 5000 }));
+    });
+    it('handles case-insensitive "true" comparison', async () => {
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(true);
+        state.execAsync.mockResolvedValue({ stdout: '  TRUE  \n', stderr: '' });
+        const result = await checkNativeMemoryAvailability(state.execAsync);
+        expect(result.available).toBe(true);
+    });
+});

package/dist/tests/native/NativeMemoryManager.availability.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/native/NativeMemoryManager.availability.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const state = vi.hoisted(() => ({
+    isWindows: vi.fn(),
+    isKoffiAvailable: vi.fn(),
+}));
+vi.mock('@native/Win32API', () => ({
+    isWindows: state.isWindows,
+    isKoffiAvailable: state.isKoffiAvailable,
+}));
+import { checkNativeMemoryAvailability } from '../../src/native/NativeMemoryManager.availability.js';
+describe('NativeMemoryManager.availability', () => {
+    const execAsync = vi.fn();
+    beforeEach(() => {
+        vi.clearAllMocks();
+        state.isWindows.mockReturnValue(true);
+        state.isKoffiAvailable.mockReturnValue(true);
+    });
+    it('rejects non-Windows platforms early', async () => {
+        state.isWindows.mockReturnValue(false);
+        await expect(checkNativeMemoryAvailability(execAsync)).resolves.toEqual({
+            available: false,
+            reason: `Native memory operations only supported on Windows. Current platform: ${process.platform}`,
+        });
+        expect(execAsync).not.toHaveBeenCalled();
+    });
+    it('rejects when koffi is unavailable', async () => {
+        state.isKoffiAvailable.mockReturnValue(false);
+        await expect(checkNativeMemoryAvailability(execAsync)).resolves.toEqual({
+            available: false,
+            reason: 'koffi library not available. Install with: pnpm add koffi',
+        });
+        expect(execAsync).not.toHaveBeenCalled();
+    });
+    it('rejects when the admin check returns false', async () => {
+        execAsync.mockResolvedValue({ stdout: 'False\r\n', stderr: '' });
+        await expect(checkNativeMemoryAvailability(execAsync)).resolves.toEqual({
+            available: false,
+            reason: 'Native memory operations require Administrator privileges. Run as Administrator.',
+        });
+        expect(execAsync).toHaveBeenCalledWith(expect.stringContaining('powershell.exe'), { timeout: 5000 });
+    });
+    it('rejects when the admin check throws', async () => {
+        execAsync.mockRejectedValue(new Error('spawn failed'));
+        await expect(checkNativeMemoryAvailability(execAsync)).resolves.toEqual({
+            available: false,
+            reason: 'Failed to check Administrator privileges.',
+        });
+    });
+    it('returns available when all prerequisites pass', async () => {
+        execAsync.mockResolvedValue({ stdout: 'true\n', stderr: '' });
+        await expect(checkNativeMemoryAvailability(execAsync)).resolves.toEqual({ available: true });
+    });
+});

package/dist/tests/native/NativeMemoryManager.impl.extended.test.d.ts

@@ -0,0 +1 @@
+export {};