@jshookmcp/jshook 0.2.1 → 0.2.2

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

@@ -1,220 +0,0 @@
-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/modules/stealth/StealthScripts.test.d.ts

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

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

@@ -1,67 +0,0 @@
-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),
-    };
-}
-describe('StealthScripts', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('injectAll invokes all stealth patch methods', async () => {
-        const page = createPageMock();
-        const spies = [
-            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),
-        ];
-        await StealthScripts.injectAll(page);
-        spies.forEach((spy) => expect(spy).toHaveBeenCalledOnce());
-    });
-    it('hideWebDriver injects a preload script', async () => {
-        const page = createPageMock();
-        await StealthScripts.hideWebDriver(page);
-        expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
-        const [script] = page.evaluateOnNewDocument.mock.calls[0];
-        expect(typeof script).toBe('function');
-    });
-    it('setRealisticUserAgent uses platform-specific UA and navigator overrides', async () => {
-        const page = createPageMock();
-        await StealthScripts.setRealisticUserAgent(page, 'mac');
-        expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Macintosh'));
-        const [script, platformValue] = page.evaluateOnNewDocument.mock.calls[0];
-        expect(typeof script).toBe('function');
-        expect(platformValue).toBe('MacIntel');
-    });
-    it('setRealisticUserAgent defaults to windows platform', 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('exposes hardened browser launch arguments', () => {
-        const args = StealthScripts.getRecommendedLaunchArgs();
-        expect(args).toContain('--disable-blink-features=AutomationControlled');
-        expect(args).toContain('--no-sandbox');
-        expect(args).toContain('--window-size=1920,1080');
-        expect(new Set(args).size).toBe(args.length);
-    });
-    it('fixPermissions and fixMediaDevices both inject scripts', async () => {
-        const page = createPageMock();
-        await StealthScripts.fixPermissions(page);
-        await StealthScripts.fixMediaDevices(page);
-        expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/tests/modules/symbolic/JSVMPSymbolicExecutor.test.d.ts

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

package/dist/tests/modules/symbolic/JSVMPSymbolicExecutor.test.js

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { JSVMPOpcode, JSVMPSymbolicExecutor, } from '../../../src/modules/symbolic/JSVMPSymbolicExecutor.js';
-describe('JSVMPSymbolicExecutor', () => {
-    it('executes arithmetic stack instructions', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: JSVMPOpcode.PUSH, operands: [2], location: 0 },
-            { opcode: JSVMPOpcode.PUSH, operands: [3], location: 1 },
-            { opcode: JSVMPOpcode.ADD, operands: [], location: 2 },
-            { opcode: JSVMPOpcode.HALT, operands: [], location: 3 },
-        ];
-        const result = await executor.executeJSVMP({ instructions });
-        expect(result.executionTrace.length).toBeGreaterThan(0);
-        expect(result.finalState.stack.length).toBe(1);
-        expect(result.confidence).toBeGreaterThan(0);
-    });
-    it('adds path constraint for JZ instruction', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: JSVMPOpcode.PUSH, operands: [0], location: 0 },
-            { opcode: JSVMPOpcode.JZ, operands: [3], location: 1 },
-            { opcode: JSVMPOpcode.PUSH, operands: [1], location: 2 },
-            { opcode: JSVMPOpcode.HALT, operands: [], location: 3 },
-        ];
-        const result = await executor.executeJSVMP({ instructions });
-        expect(result.finalState.pathConstraints.some((c) => c.type === 'equality')).toBe(true);
-        expect(result.finalState.pc).toBe(4);
-    });
-    it('handles unknown opcode by advancing pc', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: 0xab, operands: [], location: 0 },
-            { opcode: JSVMPOpcode.HALT, operands: [], location: 1 },
-        ];
-        const result = await executor.executeJSVMP({ instructions });
-        expect(result.executionTrace[0]?.pc).toBe(0);
-        expect(result.finalState.pc).toBe(2);
-    });
-    it('stops when maxSteps is reached', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = [
-            { opcode: JSVMPOpcode.NOP, operands: [], location: 0 },
-            { opcode: JSVMPOpcode.NOP, operands: [], location: 1 },
-            { opcode: JSVMPOpcode.NOP, operands: [], location: 2 },
-        ];
-        const result = await executor.executeJSVMP({ instructions, maxSteps: 1 });
-        expect(result.executionTrace.length).toBe(1);
-    });
-    it('records warning when timeout is exceeded', async () => {
-        const executor = new JSVMPSymbolicExecutor();
-        const instructions = Array.from({ length: 20 }, (_, i) => ({
-            opcode: JSVMPOpcode.NOP,
-            operands: [],
-            location: i,
-        }));
-        const result = await executor.executeJSVMP({ instructions, timeout: -1 });
-        expect(result.warnings.length).toBeGreaterThan(0);
-    });
-});

package/dist/tests/modules/symbolic/SymbolicExecutor.test.d.ts

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

package/dist/tests/modules/symbolic/SymbolicExecutor.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { SymbolicExecutor } from '../../../src/modules/symbolic/SymbolicExecutor.js';
-describe('SymbolicExecutor', () => {
-    it('creates symbolic values with unique ids', () => {
-        const executor = new SymbolicExecutor();
-        const a = executor.createSymbolicValue('number', 'a');
-        const b = executor.createSymbolicValue('number', 'b');
-        expect(a.id).not.toBe(b.id);
-        expect(a.name).toBe('a');
-    });
-    it('executes simple code and returns result shape', async () => {
-        const executor = new SymbolicExecutor();
-        const result = await executor.execute({
-            code: 'let x = 1; if (x) { x = 2; }',
-            maxPaths: 5,
-            maxDepth: 5,
-        });
-        expect(result).toHaveProperty('paths');
-        expect(result).toHaveProperty('coverage');
-        expect(result.stats.totalPaths).toBeGreaterThanOrEqual(0);
-    });
-    it('stops with timeout warning when timeout is too small', async () => {
-        const executor = new SymbolicExecutor();
-        const result = await executor.execute({
-            code: 'let x=0; while(x<10){ x=x+1; }',
-            timeout: 0,
-            maxPaths: 10,
-        });
-        expect(result.warnings.length).toBeGreaterThan(0);
-    });
-    it('marks contradictory constraints unsatisfiable in solver', () => {
-        const executor = new SymbolicExecutor();
-        const constraints = [
-            { type: 'range', expression: 'x > 10', description: '' },
-            { type: 'inequality', expression: 'x < 5', description: '' },
-        ];
-        const solved = executor.simpleSMTSolver(constraints);
-        expect(solved.satisfiable).toBe(false);
-    });
-    it('detects contradictory expressions via helper', () => {
-        const executor = new SymbolicExecutor();
-        expect(executor.areContradictory('x > 10', 'x < 10')).toBe(true);
-        expect(executor.areContradictory('x > 1', 'x < 99')).toBe(false);
-    });
-});

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

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

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

@@ -1,68 +0,0 @@
-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

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

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

@@ -1,53 +0,0 @@
-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

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