@jshookmcp/jshook 0.1.4 → 0.1.6

package/dist/modules/process/memory/scanner.js

@@ -1,6 +1,11 @@
+import { readFileSync, openSync, readSync, closeSync } from 'node:fs';
 import { promises as fs } from 'node:fs';
 import { logger } from '../../../utils/logger.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
+import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
+import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
+import { parseProcMaps } from './linux/mapsParser.js';
+import { findPatternInBuffer } from '../../../native/NativeMemoryManager.utils.js';
 export function buildPatternBytesAndMask(pattern, patternType) {
     let patternBytes = [];
     let mask = [];
@@ -73,20 +78,27 @@ export function buildPatternBytesAndMask(pattern, patternType) {
     return { patternBytes, mask };
 }
 export function patternToBytesMac(pattern, patternType) {
+    const bytes = [];
+    const mask = [];
     switch (patternType) {
         case 'hex': {
-            const bytes = [];
-            for (const part of pattern.trim().split(/\s+/)) {
-                if (part === '??' || part === '?' || part === '**')
-                    continue;
-                const b = parseInt(part, 16);
-                if (isNaN(b))
-                    throw new Error(`Invalid hex byte: ${part}`);
-                bytes.push(b);
+            const parts = pattern.trim().split(/\s+/);
+            for (const part of parts) {
+                if (part === '??' || part === '?' || part === '**') {
+                    bytes.push(0);
+                    mask.push(0);
+                }
+                else {
+                    const b = parseInt(part, 16);
+                    if (isNaN(b))
+                        throw new Error(`Invalid hex byte: ${part}`);
+                    bytes.push(b);
+                    mask.push(1);
+                }
             }
             if (!bytes.length)
-                throw new Error('Pattern is empty or all wildcards');
-            return bytes;
+                throw new Error('Pattern is empty');
+            break;
         }
         case 'int32': {
             const v = parseInt(pattern);
@@ -94,12 +106,18 @@ export function patternToBytesMac(pattern, patternType) {
                 throw new Error('Invalid int32 value');
             const buf = Buffer.allocUnsafe(4);
             buf.writeInt32LE(v, 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
         case 'int64': {
             const buf = Buffer.allocUnsafe(8);
             buf.writeBigInt64LE(BigInt.asIntN(64, BigInt(pattern)), 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
         case 'float': {
             const v = parseFloat(pattern);
@@ -107,7 +125,10 @@ export function patternToBytesMac(pattern, patternType) {
                 throw new Error('Invalid float value');
             const buf = Buffer.allocUnsafe(4);
             buf.writeFloatLE(v, 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
         case 'double': {
             const v = parseFloat(pattern);
@@ -115,13 +136,21 @@ export function patternToBytesMac(pattern, patternType) {
                 throw new Error('Invalid double value');
             const buf = Buffer.allocUnsafe(8);
             buf.writeDoubleLE(v, 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
+        }
+        case 'string': {
+            const arr = Array.from(Buffer.from(pattern, 'utf8'));
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
-        case 'string':
-            return Array.from(Buffer.from(pattern, 'utf8'));
         default:
             throw new Error(`Unsupported pattern type: ${patternType}`);
     }
+    return { bytes, mask };
 }
 function buildMemoryScanScript(pid, pattern, patternType) {
     const { patternBytes, mask } = buildPatternBytesAndMask(pattern, patternType);
@@ -255,6 +284,28 @@ try {
 }
 async function scanMemoryWindows(pid, pattern, patternType) {
     try {
+        if (isKoffiAvailable()) {
+            try {
+                const nativeResult = await nativeMemoryManager.scanMemory(pid, pattern, patternType);
+                if (nativeResult.success) {
+                    return nativeResult;
+                }
+                logger.warn('Native Windows memory scan failed, falling back to PowerShell', {
+                    pid,
+                    patternType,
+                    error: nativeResult.error,
+                    nativeAvailable: isKoffiAvailable(),
+                });
+            }
+            catch (error) {
+                logger.warn('Native Windows memory scan threw, falling back to PowerShell', {
+                    pid,
+                    patternType,
+                    error: error instanceof Error ? error.message : String(error),
+                    nativeAvailable: isKoffiAvailable(),
+                });
+            }
+        }
         const psScript = buildMemoryScanScript(pid, pattern, patternType);
         const { stdout, stderr } = await executePowerShellScript(psScript, {
             maxBuffer: 1024 * 1024 * 50,
@@ -283,22 +334,166 @@ async function scanMemoryWindows(pid, pattern, patternType) {
         };
     }
 }
-async function scanMemoryLinux(_pid, _pattern, _patternType) {
-    return {
-        success: false,
-        addresses: [],
-        error: 'Memory scanning on Linux requires scanning /proc/pid/maps and iterating regions. Use scanmem or GameConqueror for now.',
-    };
+function formatLinuxProcAccessError(pid, procFile, error) {
+    const err = error;
+    switch (err?.code) {
+        case 'ENOENT':
+        case 'ESRCH':
+            return `Process ${pid} no longer exists or /proc/${pid}/${procFile} is unavailable.`;
+        case 'EACCES':
+        case 'EPERM':
+            return `Cannot access /proc/${pid}/${procFile}. Requires root privileges or ptrace access.`;
+        default:
+            return err instanceof Error ? err.message : String(error);
+    }
+}
+async function scanMemoryLinux(pid, pattern, patternType) {
+    let patternBytes;
+    let mask;
+    try {
+        const result = buildPatternBytesAndMask(pattern, patternType);
+        patternBytes = result.patternBytes;
+        mask = result.mask;
+    }
+    catch (error) {
+        return {
+            success: false,
+            addresses: [],
+            error: error instanceof Error ? error.message : 'Invalid pattern',
+        };
+    }
+    try {
+        let mapsContent;
+        try {
+            mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
+        }
+        catch (error) {
+            return {
+                success: false,
+                addresses: [],
+                error: formatLinuxProcAccessError(pid, 'maps', error),
+            };
+        }
+        const linuxRegions = parseProcMaps(mapsContent).filter(r => r.permissions.read);
+        let fd;
+        try {
+            fd = openSync(`/proc/${pid}/mem`, 'r');
+        }
+        catch (error) {
+            return {
+                success: false,
+                addresses: [],
+                error: formatLinuxProcAccessError(pid, 'mem', error),
+            };
+        }
+        const foundAddresses = new Set();
+        const chunkSize = 16 * 1024 * 1024;
+        const maxResults = 10000;
+        const overlap = Math.max(patternBytes.length - 1, 0);
+        try {
+            for (const region of linuxRegions) {
+                if (foundAddresses.size >= maxResults)
+                    break;
+                if (region.end <= region.start)
+                    continue;
+                let chunkOffset = 0n;
+                let carryOver = Buffer.alloc(0);
+                const regionSize = region.end - region.start;
+                while (chunkOffset < regionSize && foundAddresses.size < maxResults) {
+                    const remaining = regionSize - chunkOffset;
+                    const readSize = Number(remaining > BigInt(chunkSize) ? BigInt(chunkSize) : remaining);
+                    const chunkBuffer = Buffer.allocUnsafe(readSize);
+                    let bytesRead;
+                    try {
+                        bytesRead = readSync(fd, chunkBuffer, 0, readSize, region.start + chunkOffset);
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err?.code === 'EIO' || err?.code === 'EFAULT' || err?.code === 'EACCES' || err?.code === 'EPERM') {
+                            logger.debug('Skipping unreadable Linux memory region chunk', {
+                                pid,
+                                start: `0x${region.start.toString(16)}`,
+                                offset: chunkOffset.toString(),
+                                code: err.code,
+                            });
+                            break;
+                        }
+                        throw error;
+                    }
+                    if (bytesRead <= 0) {
+                        break;
+                    }
+                    const chunk = bytesRead === readSize ? chunkBuffer : chunkBuffer.subarray(0, bytesRead);
+                    const scanBuffer = carryOver.length > 0 ? Buffer.concat([carryOver, chunk]) : chunk;
+                    const scanBase = region.start + chunkOffset - BigInt(carryOver.length);
+                    const chunkAdvance = BigInt(bytesRead);
+                    const isLastChunk = chunkOffset + chunkAdvance >= regionSize || bytesRead < readSize;
+                    const deferredTail = isLastChunk ? 0 : Math.min(overlap, scanBuffer.length);
+                    const reportableLimit = scanBuffer.length - deferredTail;
+                    const matches = findPatternInBuffer(scanBuffer, patternBytes, mask);
+                    for (const matchOffset of matches) {
+                        if (!isLastChunk && matchOffset >= reportableLimit) {
+                            continue;
+                        }
+                        const absoluteAddress = scanBase + BigInt(matchOffset);
+                        if (absoluteAddress < region.start || absoluteAddress >= region.end) {
+                            continue;
+                        }
+                        foundAddresses.add(`0x${absoluteAddress.toString(16)}`);
+                        if (foundAddresses.size >= maxResults) {
+                            break;
+                        }
+                    }
+                    if (deferredTail > 0) {
+                        carryOver = scanBuffer.subarray(scanBuffer.length - deferredTail);
+                    }
+                    else {
+                        carryOver = Buffer.alloc(0);
+                    }
+                    chunkOffset += chunkAdvance;
+                    if (bytesRead < readSize) {
+                        logger.debug('Linux memory scan stopped after short read', {
+                            pid,
+                            start: `0x${region.start.toString(16)}`,
+                            requested: readSize,
+                            bytesRead,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        const addresses = Array.from(foundAddresses);
+        return {
+            success: true,
+            addresses,
+            stats: { patternLength: patternBytes.length, resultsFound: addresses.length },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            addresses: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
 }
 async function scanMemoryMac(pid, pattern, patternType) {
     let patternBytes;
+    let patternMask;
     try {
-        patternBytes = patternToBytesMac(pattern, patternType);
+        const result = patternToBytesMac(pattern, patternType);
+        patternBytes = result.bytes;
+        patternMask = result.mask;
     }
     catch (e) {
         return { success: false, addresses: [], error: e instanceof Error ? e.message : 'Invalid pattern' };
     }
     const byteList = patternBytes.map(b => `0x${b.toString(16)}`).join(',');
+    const maskList = patternMask.join(',');
     const tag = `${pid}_${Date.now()}`;
     const pyFile = `/tmp/lldb_scan_${tag}.py`;
     const cmdFile = `/tmp/lldb_scan_${tag}.txt`;
@@ -308,6 +503,7 @@ import lldb, json, sys
 def __lldb_init_module(debugger, internal_dict):
     proc = debugger.GetSelectedTarget().GetProcess()
     pat = bytes([${byteList}])
+    mask = [${maskList}]
     results = []
     rl = proc.GetMemoryRegions()
     for i in range(rl.GetSize()):
@@ -325,7 +521,12 @@ def __lldb_init_module(debugger, internal_dict):
             continue
         n = len(pat)
         for j in range(len(data) - n + 1):
-            if data[j:j+n] == pat:
+            match = True
+            for k in range(n):
+                if mask[k] == 1 and data[j+k] != pat[k]:
+                    match = False
+                    break
+            if match:
                 results.append(hex(s + j))
                 if len(results) >= 1000:
                     break
@@ -412,4 +613,3 @@ export async function scanMemoryFiltered(pid, pattern, addresses, patternType =
         stats: { resultsFound: results.length, patternLength: pattern.length },
     };
 }
-//# sourceMappingURL=scanner.js.map

package/dist/modules/process/memory/types.d.ts

@@ -64,4 +64,3 @@ export declare function executePowerShellScript(script: string, options?: {
     stdout: string;
     stderr: string;
 }>;
-//# sourceMappingURL=types.d.ts.map

package/dist/modules/process/memory/types.js

@@ -18,4 +18,3 @@ export async function executePowerShellScript(script, options = {}) {
         stderr: String(stderr ?? ''),
     };
 }
-//# sourceMappingURL=types.js.map

package/dist/modules/process/memory/writer.d.ts

@@ -9,4 +9,3 @@ export declare function batchMemoryWrite(pid: number, patches: MemoryPatch[], wr
     }[];
     error?: string;
 }>;
-//# sourceMappingURL=writer.d.ts.map

package/dist/modules/process/memory/writer.js

@@ -200,4 +200,3 @@ export async function batchMemoryWrite(pid, patches, writeFn) {
             : `Failed to write ${results.filter(r => !r.success).length} of ${results.length} patches`,
     };
 }
-//# sourceMappingURL=writer.js.map

package/dist/modules/process/memoryUtils.d.ts

@@ -49,4 +49,3 @@ export declare function enumerateModules(pid: number): Promise<{
     }[];
     error?: string;
 }>;
-//# sourceMappingURL=memoryUtils.d.ts.map

package/dist/modules/process/memoryUtils.js

@@ -47,4 +47,3 @@ export async function enumerateModules(pid) {
     const manager = new MemoryManager();
     return manager.enumerateModules(pid);
 }
-//# sourceMappingURL=memoryUtils.js.map

package/dist/modules/process/types.d.ts

@@ -54,4 +54,3 @@ export interface MemoryMonitor {
     lastValue: string;
     timer: NodeJS.Timeout;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/modules/process/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/modules/security/ExecutionSandbox.d.ts

@@ -14,4 +14,3 @@ export declare class ExecutionSandbox {
     execute(request: SandboxExecuteRequest): Promise<SandboxExecuteResult>;
     private _execute;
 }
-//# sourceMappingURL=ExecutionSandbox.d.ts.map

package/dist/modules/security/ExecutionSandbox.js

@@ -115,4 +115,3 @@ export class ExecutionSandbox {
         });
     }
 }
-//# sourceMappingURL=ExecutionSandbox.js.map

package/dist/modules/security/RedactionService.d.ts

@@ -13,4 +13,3 @@ export declare class RedactionService {
         patternNames: string[];
     };
 }
-//# sourceMappingURL=RedactionService.d.ts.map

package/dist/modules/security/RedactionService.js

@@ -99,4 +99,3 @@ export class RedactionService {
         };
     }
 }
-//# sourceMappingURL=RedactionService.js.map

package/dist/modules/stealth/StealthScripts.d.ts

@@ -15,4 +15,3 @@ export declare class StealthScripts {
     static setRealisticUserAgent(page: Page, platform?: 'windows' | 'mac' | 'linux'): Promise<void>;
     static getRecommendedLaunchArgs(): string[];
 }
-//# sourceMappingURL=StealthScripts.d.ts.map

package/dist/modules/stealth/StealthScripts.js

@@ -301,4 +301,3 @@ export class StealthScripts {
         ];
     }
 }
-//# sourceMappingURL=StealthScripts.js.map

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

@@ -68,4 +68,3 @@ export declare class JSVMPSymbolicExecutor extends SymbolicExecutor {
     private calculateConfidence;
     private cloneStateInternal;
 }
-//# sourceMappingURL=JSVMPSymbolicExecutor.d.ts.map

package/dist/modules/symbolic/JSVMPSymbolicExecutor.js

@@ -236,4 +236,3 @@ export class JSVMPSymbolicExecutor extends SymbolicExecutor {
         };
     }
 }
-//# sourceMappingURL=JSVMPSymbolicExecutor.js.map

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

@@ -66,4 +66,3 @@ export declare class SymbolicExecutor {
     createSymbolicValue(type: SymbolicValueType, name: string, source?: string): SymbolicValue;
     addConstraint(value: SymbolicValue, type: Constraint['type'], expression: string, description: string): void;
 }
-//# sourceMappingURL=SymbolicExecutor.d.ts.map

package/dist/modules/symbolic/SymbolicExecutor.js

@@ -344,4 +344,3 @@ export class SymbolicExecutor {
         });
     }
 }
-//# sourceMappingURL=SymbolicExecutor.js.map

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

@@ -7,4 +7,3 @@ export declare function checkNativeMemoryAvailability(execAsync: (command: strin
     available: boolean;
     reason?: string;
 }>;
-//# sourceMappingURL=NativeMemoryManager.availability.d.ts.map

package/dist/native/NativeMemoryManager.availability.js

@@ -29,4 +29,3 @@ export async function checkNativeMemoryAvailability(execAsync) {
     }
     return { available: true };
 }
-//# sourceMappingURL=NativeMemoryManager.availability.js.map

package/dist/native/NativeMemoryManager.d.ts

@@ -1,2 +1 @@
 export * from './NativeMemoryManager.impl.js';
-//# sourceMappingURL=NativeMemoryManager.d.ts.map

package/dist/native/NativeMemoryManager.impl.d.ts

@@ -1,5 +1,9 @@
 import type { MemoryRegion, ModuleInfo, NativeMemoryReadResult, NativeMemoryScanResult, NativeMemoryWriteResult } from './NativeMemoryManager.types.js';
 export type { MemoryRegion, ModuleInfo, NativeMemoryReadResult, NativeMemoryScanResult, NativeMemoryWriteResult, } from './NativeMemoryManager.types.js';
+export declare function scanRegionInChunks(region: {
+    baseAddress: bigint;
+    regionSize: number;
+}, patternBytes: number[], mask: number[], readChunk: (address: bigint, size: number) => Buffer<ArrayBufferLike>, chunkSize?: number): bigint[];
 export declare class NativeMemoryManager {
     checkAvailability(): Promise<{
         available: boolean;
@@ -45,4 +49,3 @@ export declare class NativeMemoryManager {
     }>;
 }
 export declare const nativeMemoryManager: NativeMemoryManager;
-//# sourceMappingURL=NativeMemoryManager.impl.d.ts.map

package/dist/native/NativeMemoryManager.impl.js

@@ -1,10 +1,38 @@
 import { logger } from '../utils/logger.js';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import { cpuLimit } from '../utils/concurrency.js';
 import { PAGE, MEM, openProcessForMemory, CloseHandle, ReadProcessMemory, WriteProcessMemory, VirtualQueryEx, VirtualProtectEx, VirtualAllocEx, CreateRemoteThread, GetModuleHandle, GetProcAddress, NtQueryInformationProcess, EnumProcessModules, GetModuleBaseName, GetModuleInformation, } from './Win32API.js';
 import { findPatternInBuffer, getProtectionString, getStateString, getTypeString, isExecutable, isReadable, isWritable, parsePattern, } from './NativeMemoryManager.utils.js';
 import { checkNativeMemoryAvailability } from './NativeMemoryManager.availability.js';
 const execAsync = promisify(exec);
+const SCAN_CHUNK_SIZE = 16 * 1024 * 1024;
+export function scanRegionInChunks(region, patternBytes, mask, readChunk, chunkSize = SCAN_CHUNK_SIZE) {
+    if (patternBytes.length === 0 || region.regionSize < patternBytes.length || chunkSize <= 0) {
+        return [];
+    }
+    const overlap = Math.max(patternBytes.length - 1, 0);
+    let carryOver = Buffer.alloc(0);
+    const matches = [];
+    for (let chunkOffset = 0; chunkOffset < region.regionSize; chunkOffset += chunkSize) {
+        const readSize = Math.min(chunkSize, region.regionSize - chunkOffset);
+        const chunkAddress = region.baseAddress + BigInt(chunkOffset);
+        const chunk = readChunk(chunkAddress, readSize);
+        const scanBuffer = carryOver.length > 0 ? Buffer.concat([carryOver, chunk]) : chunk;
+        const chunkMatches = findPatternInBuffer(scanBuffer, patternBytes, mask);
+        for (const matchOffset of chunkMatches) {
+            const regionOffset = chunkOffset + matchOffset - carryOver.length;
+            matches.push(region.baseAddress + BigInt(regionOffset));
+        }
+        if (overlap === 0 || chunkOffset + readSize >= region.regionSize) {
+            carryOver = Buffer.alloc(0);
+            continue;
+        }
+        const carrySize = Math.min(overlap, scanBuffer.length);
+        carryOver = scanBuffer.subarray(scanBuffer.length - carrySize);
+    }
+    return matches;
+}
 export class NativeMemoryManager {
     async checkAvailability() {
         return checkNativeMemoryAvailability(execAsync);
@@ -156,45 +184,65 @@ export class NativeMemoryManager {
             if (patternBytes.length === 0) {
                 return { success: false, addresses: [], error: 'Invalid pattern' };
             }
-            const handle = openProcessForMemory(pid, false);
-            const addresses = [];
             const maxResults = 10000;
+            const readableRegions = [];
+            const handle = openProcessForMemory(pid, false);
             try {
                 let address = 0n;
                 const maxAddress = BigInt('0x7FFFFFFF0000');
-                while (address < maxAddress && addresses.length < maxResults) {
+                while (address < maxAddress) {
                     const { success, info } = VirtualQueryEx(handle, address);
                     if (!success || info.RegionSize === 0n) {
                         break;
                     }
-                    if (isReadable(info) && Number(info.RegionSize) > 0 && Number(info.RegionSize) < 1024 * 1024 * 1024) {
-                        try {
-                            const regionBuffer = ReadProcessMemory(handle, info.BaseAddress, Number(info.RegionSize));
-                            const matches = findPatternInBuffer(regionBuffer, patternBytes, mask);
-                            for (const offset of matches) {
-                                const foundAddr = info.BaseAddress + BigInt(offset);
-                                addresses.push(`0x${foundAddr.toString(16).toUpperCase()}`);
-                                if (addresses.length >= maxResults)
-                                    break;
-                            }
-                        }
-                        catch {
-                        }
+                    if (isReadable(info) &&
+                        info.RegionSize > 0n &&
+                        info.RegionSize <= BigInt(Number.MAX_SAFE_INTEGER)) {
+                        readableRegions.push({
+                            baseAddress: info.BaseAddress,
+                            regionSize: Number(info.RegionSize),
+                        });
                     }
                     address = info.BaseAddress + info.RegionSize;
                 }
-                return {
-                    success: true,
-                    addresses,
-                    stats: {
-                        patternLength: patternBytes.length,
-                        resultsFound: addresses.length,
-                    },
-                };
             }
             finally {
                 CloseHandle(handle);
             }
+            const regionMatches = await Promise.all(readableRegions.map(region => cpuLimit(async () => {
+                const scanHandle = openProcessForMemory(pid, false);
+                try {
+                    try {
+                        return scanRegionInChunks(region, patternBytes, mask, (address, size) => ReadProcessMemory(scanHandle, address, size));
+                    }
+                    catch {
+                        return [];
+                    }
+                }
+                finally {
+                    CloseHandle(scanHandle);
+                }
+            })));
+            const addresses = [];
+            for (const matches of regionMatches) {
+                for (const foundAddr of matches) {
+                    addresses.push(`0x${foundAddr.toString(16).toUpperCase()}`);
+                    if (addresses.length >= maxResults) {
+                        break;
+                    }
+                }
+                if (addresses.length >= maxResults) {
+                    break;
+                }
+            }
+            return {
+                success: true,
+                addresses,
+                stats: {
+                    patternLength: patternBytes.length,
+                    resultsFound: addresses.length,
+                },
+            };
         }
         catch (error) {
             logger.error('Native memory scan failed', {
@@ -362,4 +410,3 @@ export class NativeMemoryManager {
     }
 }
 export const nativeMemoryManager = new NativeMemoryManager();
-//# sourceMappingURL=NativeMemoryManager.impl.js.map

package/dist/native/NativeMemoryManager.js

@@ -1,2 +1 @@
 export * from './NativeMemoryManager.impl.js';
-//# sourceMappingURL=NativeMemoryManager.js.map

package/dist/native/NativeMemoryManager.types.d.ts

@@ -33,4 +33,3 @@ export interface ModuleInfo {
     size: number;
 }
 export type NativePatternType = 'hex' | 'int32' | 'int64' | 'float' | 'double' | 'string';
-//# sourceMappingURL=NativeMemoryManager.types.d.ts.map

package/dist/native/NativeMemoryManager.types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=NativeMemoryManager.types.js.map

package/dist/native/NativeMemoryManager.utils.d.ts

@@ -1,5 +1,6 @@
 import { type MemoryBasicInfo } from './Win32API.js';
 import type { NativePatternType } from './NativeMemoryManager.types.js';
+export declare function isKoffiAvailable(): boolean;
 export declare function parsePattern(pattern: string, patternType: NativePatternType): {
     patternBytes: number[];
     mask: number[];
@@ -11,4 +12,3 @@ export declare function getTypeString(type: number): string;
 export declare function isReadable(info: MemoryBasicInfo): boolean;
 export declare function isWritable(protect: number): boolean;
 export declare function isExecutable(protect: number): boolean;
-//# sourceMappingURL=NativeMemoryManager.utils.d.ts.map