@bun-win32/psapi 2.0.0

package/README.md

@@ -0,0 +1,58 @@
+# bun-psapi
+
+Zero-dependency, zero-overhead Win32 PSAPI bindings for [Bun](https://bun.sh) on Windows.
+
+## Overview
+
+`bun-psapi` exposes the `psapi.dll` exports using Bun's FFI. It provides a single class, `Psapi`, which lazily binds native symbols on first use. You can optionally preload a subset or all symbols up-front via `Preload()`.
+
+## Features
+
+- [Bun](https://bun.sh)-first ergonomics on Windows 10/11.
+- Direct FFI to `psapi.dll` (process enumeration, module info, memory stats, working sets, device drivers, and more).
+- In-source docs in `structs/Psapi.ts` with links to Microsoft Docs.
+- Lazy binding on first call; optional eager preload (`Psapi.Preload()`).
+- No wrapper overhead; calls map 1:1 to native APIs.
+- Strongly-typed Win32 aliases (see `types/Psapi.ts`).
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime
+- Windows 10 or later
+
+## Installation
+
+```sh
+bun add bun-psapi
+```
+
+## Quick Start
+
+```ts
+import Psapi from 'bun-psapi';
+
+// Optionally bind a subset up-front
+Psapi.Preload(['EnumProcesses', 'GetModuleBaseNameW']);
+
+// Enumerate all process IDs
+const idBuffer = Buffer.alloc(4096);
+const sizeNeeded = Buffer.alloc(4);
+
+Psapi.EnumProcesses(idBuffer.ptr, idBuffer.byteLength, sizeNeeded.ptr);
+
+const count = sizeNeeded.readUInt32LE(0) / 4;
+console.log('Processes: %d', count);
+```
+
+## Examples
+
+Run the included example to see the library in action:
+
+```sh
+bun run example              # Process enumeration + performance info
+```
+
+## Notes
+
+- Either rely on lazy binding or call `Psapi.Preload()`.
+- Windows only. Bun runtime required.

package/index.ts

@@ -0,0 +1,6 @@
+import './runtime/extensions';
+
+import Psapi from './structs/Psapi';
+
+export * from './types/Psapi';
+export default Psapi;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "author": "Stev Peifer <stev@bell.net>",
+  "bugs": {
+    "url": "https://github.com/obscuritysrl/bun-psapi/issues"
+  },
+  "description": "Zero-dependency, zero-overhead Win32 PSAPI bindings for Bun (FFI) on Windows.",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "license": "MIT",
+  "module": "index.ts",
+  "name": "@bun-win32/psapi",
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "private": false,
+  "homepage": "https://github.com/obscuritysrl/bun-psapi#readme",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/obscuritysrl/bun-psapi.git"
+  },
+  "type": "module",
+  "version": "2.0.0",
+  "main": "./index.ts",
+  "keywords": [
+    "bun",
+    "ffi",
+    "win32",
+    "windows",
+    "psapi",
+    "bindings",
+    "typescript",
+    "dll"
+  ],
+  "files": [
+    "index.ts",
+    "runtime/*.ts",
+    "structs/*.ts",
+    "types/*.ts",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "example": "bun ./example/psapi.ts"
+  }
+}

package/runtime/extensions.ts

@@ -0,0 +1,210 @@
+import { type Pointer, ptr } from 'bun:ffi';
+
+declare global {
+  /**
+   * Adds a native pointer property to all ArrayBuffer, Buffer, DataView, and TypedArray types.
+   *
+   * The `ptr` property returns a native pointer usable with Bun FFI.
+   *
+   * @example
+   * ```ts
+   * const arr = new Uint8Array([1, 2, 3]);
+   * nativeFunction(arr.ptr, arr.length);
+   * ```
+   */
+  interface ArrayBuffer {
+    /**
+     * Native pointer to ArrayBuffer memory for Bun FFI.
+     * @example
+     * ```ts
+     * const buf = new ArrayBuffer(8);
+     * nativeFunction(buf.ptr, buf.byteLength);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface BigInt64Array {
+    /**
+     * Native pointer to BigInt64Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new BigInt64Array([1n, 2n]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface BigUint64Array {
+    /**
+     * Native pointer to BigUint64Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new BigUint64Array([1n, 2n]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Buffer {
+    /**
+     * Native pointer to Buffer memory for Bun FFI.
+     * @example
+     * ```ts
+     * const buf = Buffer.from([1, 2, 3]);
+     * nativeFunction(buf.ptr, buf.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface DataView {
+    /**
+     * Native pointer to DataView memory for Bun FFI.
+     * @example
+     * ```ts
+     * const view = new DataView(new ArrayBuffer(4));
+     * nativeFunction(view.ptr, view.byteLength);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Float32Array {
+    /**
+     * Native pointer to Float32Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Float32Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Float64Array {
+    /**
+     * Native pointer to Float64Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Float64Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Int16Array {
+    /**
+     * Native pointer to Int16Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Int16Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Int32Array {
+    /**
+     * Native pointer to Int32Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Int32Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Int8Array {
+    /**
+     * Native pointer to Int8Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Int8Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface SharedArrayBuffer {
+    /**
+     * Native pointer to SharedArrayBuffer memory for Bun FFI.
+     * @example
+     * ```ts
+     * const buf = new SharedArrayBuffer(8);
+     * nativeFunction(buf.ptr, buf.byteLength);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Uint16Array {
+    /**
+     * Native pointer to Uint16Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Uint16Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Uint32Array {
+    /**
+     * Native pointer to Uint32Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Uint32Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Uint8Array {
+    /**
+     * Native pointer to Uint8Array memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Uint8Array([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+  interface Uint8ClampedArray {
+    /**
+     * Native pointer to Uint8ClampedArray memory for Bun FFI.
+     * @example
+     * ```ts
+     * const arr = new Uint8ClampedArray([1, 2, 3]);
+     * nativeFunction(arr.ptr, arr.length);
+     * ```
+     */
+    readonly ptr: Pointer;
+  }
+}
+
+/**
+ * Installs the `ptr` property on all supported binary view prototypes.
+ *
+ * The property is non-enumerable and non-configurable. The getter calls `ptr(this)`.
+ */
+const constructors = [ArrayBuffer, BigInt64Array, BigUint64Array, Buffer, DataView, Float32Array, Float64Array, Int16Array, Int32Array, Int8Array, SharedArrayBuffer, Uint16Array, Uint32Array, Uint8Array, Uint8ClampedArray] as const;
+
+constructors.forEach(
+  ({ prototype }) =>
+    !Object.getOwnPropertyDescriptor(prototype, 'ptr') &&
+    Object.defineProperty(prototype, 'ptr', {
+      configurable: false,
+      enumerable: false,
+      /**
+       * Returns a native pointer to the underlying memory.
+       * @returns Native pointer for Bun FFI.
+       * @example
+       * ```ts
+       * const arr = new Uint8Array([1, 2, 3]);
+       * nativeFunction(arr.ptr, arr.length);
+       * ```
+       */
+      get(this): Pointer {
+        return ptr(this);
+      },
+    })
+);
+
+export {};

package/structs/Psapi.ts

@@ -0,0 +1,276 @@
+import { type FFIFunction, FFIType, dlopen } from 'bun:ffi';
+
+import type {
+  BOOL,
+  DWORD,
+  HANDLE,
+  HMODULE,
+  LPDWORD,
+  LPHMODULE,
+  LPMODULEINFO,
+  LPSTR,
+  LPVOID,
+  LPWSTR,
+  PDWORD,
+  PENUM_PAGE_FILE_CALLBACKA,
+  PENUM_PAGE_FILE_CALLBACKW,
+  PPERFORMANCE_INFORMATION,
+  PPROCESS_MEMORY_COUNTERS,
+  PPSAPI_WS_WATCH_INFORMATION,
+  PPSAPI_WS_WATCH_INFORMATION_EX,
+  PVOID,
+} from '../types/Psapi';
+
+/**
+ * Thin, lazy-loaded FFI bindings for `psapi.dll`.
+ *
+ * Each static method corresponds one-to-one with a Win32 export declared in `Symbols`.
+ * The first call to a method binds the underlying native symbol via `bun:ffi` and
+ * memoizes it on the class for subsequent calls. For bulk, up-front binding, use `Preload`.
+ *
+ * Symbols are defined with explicit `FFIType` signatures and kept alphabetized.
+ * You normally do not access `Symbols` directly; call the static methods or preload
+ * a subset for hot paths.
+ *
+ * @example
+ * ```ts
+ * import Psapi from './structs/Psapi';
+ *
+ * // Lazy: bind on first call
+ * const result = Psapi.EnumProcesses(buffer.ptr, buffer.byteLength, sizeNeeded.ptr);
+ *
+ * // Or preload a subset to avoid per-symbol lazy binding cost
+ * Psapi.Preload(['EnumProcesses', 'GetModuleBaseNameW']);
+ * ```
+ */
+class Psapi {
+  /**
+   * Lazily binds a single `psapi.dll` export and memoizes it on the class.
+   *
+   * If the symbol has already been bound (property is non-configurable), this is a no-op.
+   * Subsequent calls go directly through the memoized native function.
+   *
+   * @param method Exact export name from `Symbols`.
+   * @returns The bound native function, typed to the corresponding static method.
+   * @example
+   * ```ts
+   * // Internal usage: public wrappers call Load on first invocation
+   * // return Psapi.Load('EnumProcesses')();
+   * ```
+   */
+  private static Load<T extends keyof typeof Psapi.Symbols>(method: T): (typeof Psapi)[T] {
+    const skip = Object.getOwnPropertyDescriptor(Psapi, method)?.configurable === false;
+
+    if (skip) {
+      return Psapi[method];
+    }
+
+    const library = dlopen('psapi.dll', { [method]: Psapi.Symbols[method] });
+
+    const propertyDescriptor = { configurable: false, value: library.symbols[method] };
+    Object.defineProperty(Psapi, method, propertyDescriptor);
+
+    return Psapi[method];
+  }
+
+  /**
+   * Eagerly binds one or more `psapi.dll` exports in a single `dlopen` call.
+   *
+   * When called with no arguments, every symbol in `Symbols` is bound.
+   * Already-bound symbols are skipped.
+   *
+   * @param methods Optional list of export names to preload. Defaults to all symbols.
+   * @example
+   * ```ts
+   * // Preload specific hot-path symbols
+   * Psapi.Preload(['EnumProcessModules', 'GetModuleBaseNameW', 'GetModuleFileNameExW']);
+   *
+   * // Or preload everything
+   * Psapi.Preload();
+   * ```
+   */
+  public static Preload(methods?: (keyof typeof Psapi.Symbols)[]): void {
+    methods ??= Object.keys(Psapi.Symbols) as (keyof typeof Psapi.Symbols)[];
+
+    const symbols = Object.fromEntries(
+      methods
+        .filter((method) => Object.getOwnPropertyDescriptor(Psapi, method)?.configurable !== false)
+        .map((method) => [method, Psapi.Symbols[method]])
+    );
+
+    const library = dlopen('psapi.dll', symbols);
+
+    const propertyDescriptorMap = Object.fromEntries(
+      Object.entries(library.symbols).map(([key, value]) => [key, { configurable: false, value }])
+    );
+
+    Object.defineProperties(Psapi, propertyDescriptorMap);
+  }
+
+  private static readonly Symbols = {
+    EmptyWorkingSet: { args: [FFIType.u64], returns: FFIType.i32 },
+    EnumDeviceDrivers: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    EnumPageFilesA: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    EnumPageFilesW: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    EnumProcessModules: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    EnumProcessModulesEx: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    EnumProcesses: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+    GetDeviceDriverBaseNameA: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetDeviceDriverBaseNameW: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetDeviceDriverFileNameA: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetDeviceDriverFileNameW: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetMappedFileNameA: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetMappedFileNameW: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetModuleBaseNameA: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetModuleBaseNameW: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetModuleFileNameExA: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetModuleFileNameExW: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetModuleInformation: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    GetPerformanceInfo: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    GetProcessImageFileNameA: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetProcessImageFileNameW: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    GetProcessMemoryInfo: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    GetWsChanges: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    GetWsChangesEx: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    InitializeProcessForWsWatch: { args: [FFIType.u64], returns: FFIType.i32 },
+    QueryWorkingSet: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+    QueryWorkingSetEx: { args: [FFIType.u64, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+  } as const satisfies Record<string, FFIFunction>;
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-emptyworkingset
+  public static EmptyWorkingSet(hProcess: HANDLE): BOOL {
+    return Psapi.Load('EmptyWorkingSet')(hProcess);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-enumdevicedrivers
+  public static EnumDeviceDrivers(lpImageBase: LPVOID, cb: DWORD, lpcbNeeded: LPDWORD): BOOL {
+    return Psapi.Load('EnumDeviceDrivers')(lpImageBase, cb, lpcbNeeded);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-enumpagefilesa
+  public static EnumPageFilesA(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID): BOOL {
+    return Psapi.Load('EnumPageFilesA')(pCallBackRoutine, pContext);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-enumpagefilesw
+  public static EnumPageFilesW(pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID): BOOL {
+    return Psapi.Load('EnumPageFilesW')(pCallBackRoutine, pContext);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-enumprocessmodules
+  public static EnumProcessModules(hProcess: HANDLE, lphModule: LPHMODULE, cb: DWORD, lpcbNeeded: LPDWORD): BOOL {
+    return Psapi.Load('EnumProcessModules')(hProcess, lphModule, cb, lpcbNeeded);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-enumprocessmodulesex
+  public static EnumProcessModulesEx(hProcess: HANDLE, lphModule: LPHMODULE, cb: DWORD, lpcbNeeded: LPDWORD, dwFilterFlag: DWORD): BOOL {
+    return Psapi.Load('EnumProcessModulesEx')(hProcess, lphModule, cb, lpcbNeeded, dwFilterFlag);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-enumprocesses
+  public static EnumProcesses(lpidProcess: LPDWORD, cb: DWORD, lpcbNeeded: LPDWORD): BOOL {
+    return Psapi.Load('EnumProcesses')(lpidProcess, cb, lpcbNeeded);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getdevicedriverbasenamea
+  public static GetDeviceDriverBaseNameA(ImageBase: bigint, lpBaseName: LPSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetDeviceDriverBaseNameA')(ImageBase, lpBaseName, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getdevicedriverbasenamew
+  public static GetDeviceDriverBaseNameW(ImageBase: bigint, lpBaseName: LPWSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetDeviceDriverBaseNameW')(ImageBase, lpBaseName, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getdevicedriverfilenamea
+  public static GetDeviceDriverFileNameA(ImageBase: bigint, lpFilename: LPSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetDeviceDriverFileNameA')(ImageBase, lpFilename, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getdevicedriverfilenamew
+  public static GetDeviceDriverFileNameW(ImageBase: bigint, lpFilename: LPWSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetDeviceDriverFileNameW')(ImageBase, lpFilename, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmappedfilenamea
+  public static GetMappedFileNameA(hProcess: HANDLE, lpv: bigint, lpFilename: LPSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetMappedFileNameA')(hProcess, lpv, lpFilename, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmappedfilenamew
+  public static GetMappedFileNameW(hProcess: HANDLE, lpv: bigint, lpFilename: LPWSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetMappedFileNameW')(hProcess, lpv, lpFilename, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmodulebasenamea
+  public static GetModuleBaseNameA(hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetModuleBaseNameA')(hProcess, hModule, lpBaseName, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmodulebasenamew
+  public static GetModuleBaseNameW(hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetModuleBaseNameW')(hProcess, hModule, lpBaseName, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmodulefilenameexa
+  public static GetModuleFileNameExA(hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetModuleFileNameExA')(hProcess, hModule, lpFilename, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmodulefilenameexw
+  public static GetModuleFileNameExW(hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetModuleFileNameExW')(hProcess, hModule, lpFilename, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getmoduleinformation
+  public static GetModuleInformation(hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD): BOOL {
+    return Psapi.Load('GetModuleInformation')(hProcess, hModule, lpmodinfo, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getperformanceinfo
+  public static GetPerformanceInfo(pPerformanceInformation: PPERFORMANCE_INFORMATION, cb: DWORD): BOOL {
+    return Psapi.Load('GetPerformanceInfo')(pPerformanceInformation, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getprocessimagefilenamea
+  public static GetProcessImageFileNameA(hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetProcessImageFileNameA')(hProcess, lpImageFileName, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getprocessimagefilenamew
+  public static GetProcessImageFileNameW(hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD): DWORD {
+    return Psapi.Load('GetProcessImageFileNameW')(hProcess, lpImageFileName, nSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getprocessmemoryinfo
+  public static GetProcessMemoryInfo(Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD): BOOL {
+    return Psapi.Load('GetProcessMemoryInfo')(Process, ppsmemCounters, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getwschanges
+  public static GetWsChanges(hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD): BOOL {
+    return Psapi.Load('GetWsChanges')(hProcess, lpWatchInfo, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getwschangesex
+  public static GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: PDWORD): BOOL {
+    return Psapi.Load('GetWsChangesEx')(hProcess, lpWatchInfoEx, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-initializeprocessforwswatch
+  public static InitializeProcessForWsWatch(hProcess: HANDLE): BOOL {
+    return Psapi.Load('InitializeProcessForWsWatch')(hProcess);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-queryworkingset
+  public static QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD): BOOL {
+    return Psapi.Load('QueryWorkingSet')(hProcess, pv, cb);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-queryworkingsetex
+  public static QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD): BOOL {
+    return Psapi.Load('QueryWorkingSetEx')(hProcess, pv, cb);
+  }
+}
+
+export default Psapi;

package/types/Psapi.ts

@@ -0,0 +1,29 @@
+import type { Pointer } from 'bun:ffi';
+
+export enum ListModulesFilterFlag {
+  LIST_MODULES_32BIT = 0x01,
+  LIST_MODULES_64BIT = 0x02,
+  LIST_MODULES_ALL = 0x03,
+  LIST_MODULES_DEFAULT = 0x00,
+}
+
+export type BOOL = number;
+export type DWORD = number;
+export type HANDLE = bigint;
+export type HMODULE = bigint;
+export type LPCSTR = Pointer;
+export type LPCWSTR = Pointer;
+export type LPDWORD = Pointer;
+export type LPHMODULE = Pointer;
+export type LPMODULEINFO = Pointer;
+export type LPSTR = Pointer;
+export type LPVOID = Pointer;
+export type LPWSTR = Pointer;
+export type PDWORD = Pointer;
+export type PENUM_PAGE_FILE_CALLBACKA = Pointer;
+export type PENUM_PAGE_FILE_CALLBACKW = Pointer;
+export type PPERFORMANCE_INFORMATION = Pointer;
+export type PPROCESS_MEMORY_COUNTERS = Pointer;
+export type PPSAPI_WS_WATCH_INFORMATION = Pointer;
+export type PPSAPI_WS_WATCH_INFORMATION_EX = Pointer;
+export type PVOID = Pointer;