@bun-win32/cabinet 1.0.0

package/AI.md

@@ -0,0 +1,71 @@
+# AI Guide for @bun-win32/cabinet
+
+How to use this package, not what the Win32 API does.
+
+## Usage
+
+```ts
+import Cabinet, { SomeFlag } from '@bun-win32/cabinet';
+
+// Methods bind lazily on first call
+const result = Cabinet.SomeFunctionW(arg1, arg2);
+
+// Preload: array, single string, or no args (all symbols)
+Cabinet.Preload(['SomeFunctionW', 'AnotherFunction']);
+Cabinet.Preload('SomeFunctionW');
+Cabinet.Preload();
+```
+
+## Where To Look
+
+| Need                              | Read                 |
+| --------------------------------- | -------------------- |
+| Find a method or its MS Docs link | `structs/Cabinet.ts` |
+| Find types, enums, constants      | `types/Cabinet.ts`   |
+| Quick examples                    | `README.md`          |
+
+`index.ts` re-exports the class and all types — import from `@bun-win32/cabinet` directly.
+
+## Calling Convention
+
+All documented `cabinet.dll` exports are bound. Each method maps 1:1 to its DLL export. Names, parameter names, and order match Microsoft Docs.
+
+### Strings
+
+`W` methods take UTF-16LE NUL-terminated buffers. `A` methods take ANSI strings.
+
+```ts
+const wide = Buffer.from('Hello\0', 'utf16le');  // LPCWSTR
+Cabinet.SomeFunctionW(wide.ptr);
+
+// Reading a wide string back from a buffer:
+const text = new TextDecoder('utf-16').decode(buf).replace(/\0.*$/, '');
+```
+
+### Return types
+
+- `HANDLE`, `HWND`, etc. → `bigint`
+- `DWORD`, `UINT`, `BOOL`, `INT`, `LONG` → `number`
+- `LPVOID`, `LPWSTR`, etc. → `Pointer`
+- Win32 `BOOL` is `number` (0 or non-zero), **not** JS `boolean`. Do not compare with `=== true`.
+
+### Pointers, handles, out-parameters
+
+- **Pointer** params (`LP*`, `P*`, `Pointer`): pass `buffer.ptr` from a caller-allocated `Buffer`.
+- **Handle** params (`HANDLE`, `HWND`, etc.): pass a `bigint` value.
+- **Out-parameters**: allocate a `Buffer`, pass `.ptr`, read the result after the call.
+
+```ts
+const out = Buffer.alloc(4);
+Cabinet.SomeFunction(out.ptr);
+const value = out.readUInt32LE(0);
+```
+
+### Nullability
+
+- `| NULL` in a signature → pass `null` (optional pointer).
+- `| 0n` in a signature → pass `0n` (optional handle).
+
+## Errors and Cleanup
+
+Return values are raw. If the Win32 function uses last-error semantics, read via `GetLastError()`. Resource cleanup is your responsibility — same as raw Win32.

package/README.md

@@ -0,0 +1,80 @@
+# @bun-win32/cabinet
+
+Zero-dependency, zero-overhead Win32 Cabinet bindings for [Bun](https://bun.sh) on Windows.
+
+## Overview
+
+`@bun-win32/cabinet` exposes the `cabinet.dll` exports using [Bun](https://bun.sh)'s FFI. It provides a single class, `Cabinet`, which lazily binds native symbols on first use. You can optionally preload a subset or all symbols up-front via `Preload()`.
+
+The bindings are strongly typed for a smooth DX in TypeScript.
+
+## Features
+
+- [Bun](https://bun.sh)-first ergonomics on Windows 10/11.
+- Direct FFI to `cabinet.dll` (Compression API — MSZIP / XPRESS / XPRESS-Huffman / LZMS — plus FCI/FDI Cabinet (.cab) archive creation and extraction).
+- In-source docs in `structs/Cabinet.ts` with links to Microsoft Docs.
+- Lazy binding on first call; optional eager preload (`Cabinet.Preload()`).
+- No wrapper overhead; calls map 1:1 to native APIs.
+- Strongly-typed Win32 aliases (see `types/Cabinet.ts`).
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime
+- Windows 10 or later
+
+## Installation
+
+```sh
+bun add @bun-win32/cabinet
+```
+
+## Quick Start
+
+```ts
+import Cabinet, { COMPRESS_ALGORITHM } from '@bun-win32/cabinet';
+
+const input = Buffer.from('compress me '.repeat(64));
+
+// Create an XPRESS-Huffman compressor (handle is returned through an out-buffer)
+const hCompressor = Buffer.alloc(8);
+Cabinet.CreateCompressor(COMPRESS_ALGORITHM.COMPRESS_ALGORITHM_XPRESS_HUFF, null, hCompressor.ptr);
+const compressor = hCompressor.readBigUInt64LE(0);
+
+// Sizing call: a NULL buffer reports the required size, then compress for real
+const size = Buffer.alloc(8);
+Cabinet.Compress(compressor, input.ptr, BigInt(input.length), null, 0n, size.ptr);
+const compressed = Buffer.alloc(Number(size.readBigUInt64LE(0)));
+Cabinet.Compress(compressor, input.ptr, BigInt(input.length), compressed.ptr, BigInt(compressed.length), size.ptr);
+const compressedSize = Number(size.readBigUInt64LE(0));
+Cabinet.CloseCompressor(compressor);
+
+// Decompress back and verify the round trip
+const hDecompressor = Buffer.alloc(8);
+Cabinet.CreateDecompressor(COMPRESS_ALGORITHM.COMPRESS_ALGORITHM_XPRESS_HUFF, null, hDecompressor.ptr);
+const decompressor = hDecompressor.readBigUInt64LE(0);
+const restored = Buffer.alloc(input.length);
+Cabinet.Decompress(decompressor, compressed.ptr, BigInt(compressedSize), restored.ptr, BigInt(restored.length), null);
+Cabinet.CloseDecompressor(decompressor);
+
+console.log(`${input.length} → ${compressedSize} bytes · round-trip ok: ${restored.equals(input)}`);
+```
+
+> [!NOTE]
+> AI agents: see `AI.md` for the package binding contract and source-navigation guidance. It explains how to use the package without scanning the entire implementation.
+
+## Examples
+
+Run the included examples:
+
+```sh
+# Live algorithm race: MSZIP vs XPRESS vs XPRESS-Huffman vs LZMS, animated
+bun run example/compression-arena.ts
+
+# Build a real .cab with FCI, then inspect + extract + verify it with FDI
+bun run example/cabinet-workshop.ts
+```
+
+## Notes
+
+- Either rely on lazy binding or call `Cabinet.Preload()`.
+- Windows only. Bun runtime required.

package/index.ts

@@ -0,0 +1,4 @@
+import Cabinet from './structs/Cabinet';
+
+export * from './types/Cabinet';
+export default Cabinet;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "author": "Stev Peifer <stev@bell.net>",
+  "bugs": {
+    "url": "https://github.com/ObscuritySRL/bun-win32/issues"
+  },
+  "dependencies": {
+    "@bun-win32/core": "1.1.2"
+  },
+  "description": "Zero-dependency, zero-overhead Win32 CABINET bindings for Bun (FFI) on Windows.",
+  "devDependencies": {
+    "@bun-win32/kernel32": "1.0.21",
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./index.ts"
+  },
+  "license": "MIT",
+  "module": "index.ts",
+  "name": "@bun-win32/cabinet",
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "private": false,
+  "homepage": "https://github.com/ObscuritySRL/bun-win32#readme",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ObscuritySRL/bun-win32.git",
+    "directory": "packages/cabinet"
+  },
+  "type": "module",
+  "version": "1.0.0",
+  "main": "./index.ts",
+  "keywords": [
+    "bun",
+    "ffi",
+    "win32",
+    "windows",
+    "cabinet",
+    "bindings",
+    "typescript",
+    "dll"
+  ],
+  "files": [
+    "AI.md",
+    "README.md",
+    "index.ts",
+    "structs/*.ts",
+    "types/*.ts"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "example:cabinet-workshop": "bun ./example/cabinet-workshop.ts",
+    "example:compression-arena": "bun ./example/compression-arena.ts"
+  }
+}

package/structs/Cabinet.ts

@@ -0,0 +1,239 @@
+import { type FFIFunction, FFIType } from 'bun:ffi';
+
+import { Win32 } from '@bun-win32/core';
+
+import type {
+  BOOL,
+  COMPRESS_INFORMATION_CLASS,
+  COMPRESSOR_HANDLE,
+  DECOMPRESSOR_HANDLE,
+  DWORD,
+  HFCI,
+  HFDI,
+  INT,
+  INT_PTR,
+  LPCVOID,
+  LPSTR,
+  LPVOID,
+  NULL,
+  PCABINETDLLVERSIONINFO,
+  PCCAB,
+  PCOMPRESS_ALLOCATION_ROUTINES,
+  PCOMPRESSOR_HANDLE,
+  PDECOMPRESSOR_HANDLE,
+  PERF,
+  PFDICABINETINFO,
+  PFNALLOC,
+  PFNCLOSE,
+  PFNFCIALLOC,
+  PFNFCICLOSE,
+  PFNFCIDELETE,
+  PFNFCIFILEPLACED,
+  PFNFCIFREE,
+  PFNFCIGETNEXTCABINET,
+  PFNFCIGETOPENINFO,
+  PFNFCIGETTEMPFILE,
+  PFNFCIOPEN,
+  PFNFCIREAD,
+  PFNFCISEEK,
+  PFNFCISTATUS,
+  PFNFCIWRITE,
+  PFNFDIDECRYPT,
+  PFNFDINOTIFY,
+  PFNFREE,
+  PFNOPEN,
+  PFNREAD,
+  PFNSEEK,
+  PFNWRITE,
+  PSIZE_T,
+  PVOID,
+  SIZE_T,
+  TCOMP,
+  USHORT,
+  VOID,
+} from '../types/Cabinet';
+
+/**
+ * Thin, lazy-loaded FFI bindings for `cabinet.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 Cabinet from './structs/Cabinet';
+ *
+ * // Lazy: bind on first call
+ * const handle = Buffer.alloc(8);
+ * Cabinet.CreateCompressor(COMPRESS_ALGORITHM.COMPRESS_ALGORITHM_XPRESS, null, handle.ptr);
+ *
+ * // Or preload a subset to avoid per-symbol lazy binding cost
+ * Cabinet.Preload(['CreateCompressor', 'Compress', 'CloseCompressor']);
+ * ```
+ */
+class Cabinet extends Win32 {
+  protected static override name = 'cabinet.dll';
+
+  /** @inheritdoc */
+  protected static override readonly Symbols = {
+    CloseCompressor: { args: [FFIType.u64], returns: FFIType.i32 },
+    CloseDecompressor: { args: [FFIType.u64], returns: FFIType.i32 },
+    Compress: { args: [FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    CreateCompressor: { args: [FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    CreateDecompressor: { args: [FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    Decompress: { args: [FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+    DllGetVersion: { args: [FFIType.ptr], returns: FFIType.void },
+    FCIAddFile: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u16], returns: FFIType.i32 },
+    FCICreate: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.u64 },
+    FCIDestroy: { args: [FFIType.u64], returns: FFIType.i32 },
+    FCIFlushCabinet: { args: [FFIType.u64, FFIType.i32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    FCIFlushFolder: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    FDICopy: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+    FDICreate: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr], returns: FFIType.u64 },
+    FDIDestroy: { args: [FFIType.u64], returns: FFIType.i32 },
+    FDIIsCabinet: { args: [FFIType.u64, FFIType.i64, FFIType.ptr], returns: FFIType.i32 },
+    FDITruncateCabinet: { args: [FFIType.u64, FFIType.ptr, FFIType.u16], returns: FFIType.i32 },
+    QueryCompressorInformation: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    QueryDecompressorInformation: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    ResetCompressor: { args: [FFIType.u64], returns: FFIType.i32 },
+    ResetDecompressor: { args: [FFIType.u64], returns: FFIType.i32 },
+    SetCompressorInformation: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+    SetDecompressorInformation: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+  } as const satisfies Record<string, FFIFunction>;
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-closecompressor
+  public static CloseCompressor(CompressorHandle: COMPRESSOR_HANDLE): BOOL {
+    return Cabinet.Load('CloseCompressor')(CompressorHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-closedecompressor
+  public static CloseDecompressor(DecompressorHandle: DECOMPRESSOR_HANDLE): BOOL {
+    return Cabinet.Load('CloseDecompressor')(DecompressorHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-compress
+  public static Compress(CompressorHandle: COMPRESSOR_HANDLE, UncompressedData: LPCVOID | NULL, UncompressedDataSize: SIZE_T, CompressedBuffer: PVOID | NULL, CompressedBufferSize: SIZE_T, CompressedDataSize: PSIZE_T): BOOL {
+    return Cabinet.Load('Compress')(CompressorHandle, UncompressedData, UncompressedDataSize, CompressedBuffer, CompressedBufferSize, CompressedDataSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-createcompressor
+  public static CreateCompressor(Algorithm: DWORD, AllocationRoutines: PCOMPRESS_ALLOCATION_ROUTINES | NULL, CompressorHandle: PCOMPRESSOR_HANDLE): BOOL {
+    return Cabinet.Load('CreateCompressor')(Algorithm, AllocationRoutines, CompressorHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-createdecompressor
+  public static CreateDecompressor(Algorithm: DWORD, AllocationRoutines: PCOMPRESS_ALLOCATION_ROUTINES | NULL, DecompressorHandle: PDECOMPRESSOR_HANDLE): BOOL {
+    return Cabinet.Load('CreateDecompressor')(Algorithm, AllocationRoutines, DecompressorHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-decompress
+  public static Decompress(DecompressorHandle: DECOMPRESSOR_HANDLE, CompressedData: LPCVOID | NULL, CompressedDataSize: SIZE_T, UncompressedBuffer: PVOID | NULL, UncompressedBufferSize: SIZE_T, UncompressedDataSize: PSIZE_T | NULL): BOOL {
+    return Cabinet.Load('Decompress')(DecompressorHandle, CompressedData, CompressedDataSize, UncompressedBuffer, UncompressedBufferSize, UncompressedDataSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/devnotes/dllgetversion
+  public static DllGetVersion(pcdvi: PCABINETDLLVERSIONINFO): VOID {
+    return Cabinet.Load('DllGetVersion')(pcdvi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fci/nf-fci-fciaddfile
+  public static FCIAddFile(hfci: HFCI, pszSourceFile: LPSTR, pszFileName: LPSTR, fExecute: BOOL, pfnfcignc: PFNFCIGETNEXTCABINET, pfnfcis: PFNFCISTATUS, pfnfcigoi: PFNFCIGETOPENINFO, typeCompress: TCOMP): BOOL {
+    return Cabinet.Load('FCIAddFile')(hfci, pszSourceFile, pszFileName, fExecute, pfnfcignc, pfnfcis, pfnfcigoi, typeCompress);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fci/nf-fci-fcicreate
+  public static FCICreate(
+    perf: PERF,
+    pfnfcifp: PFNFCIFILEPLACED,
+    pfna: PFNFCIALLOC,
+    pfnf: PFNFCIFREE,
+    pfnopen: PFNFCIOPEN,
+    pfnread: PFNFCIREAD,
+    pfnwrite: PFNFCIWRITE,
+    pfnclose: PFNFCICLOSE,
+    pfnseek: PFNFCISEEK,
+    pfndelete: PFNFCIDELETE,
+    pfnfcigtf: PFNFCIGETTEMPFILE,
+    pccab: PCCAB,
+    pv: LPVOID | NULL,
+  ): HFCI {
+    return Cabinet.Load('FCICreate')(perf, pfnfcifp, pfna, pfnf, pfnopen, pfnread, pfnwrite, pfnclose, pfnseek, pfndelete, pfnfcigtf, pccab, pv);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fci/nf-fci-fcidestroy
+  public static FCIDestroy(hfci: HFCI): BOOL {
+    return Cabinet.Load('FCIDestroy')(hfci);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fci/nf-fci-fciflushcabinet
+  public static FCIFlushCabinet(hfci: HFCI, fGetNextCab: BOOL, pfnfcignc: PFNFCIGETNEXTCABINET, pfnfcis: PFNFCISTATUS): BOOL {
+    return Cabinet.Load('FCIFlushCabinet')(hfci, fGetNextCab, pfnfcignc, pfnfcis);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fci/nf-fci-fciflushfolder
+  public static FCIFlushFolder(hfci: HFCI, pfnfcignc: PFNFCIGETNEXTCABINET, pfnfcis: PFNFCISTATUS): BOOL {
+    return Cabinet.Load('FCIFlushFolder')(hfci, pfnfcignc, pfnfcis);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fdicopy
+  public static FDICopy(hfdi: HFDI, pszCabinet: LPSTR, pszCabPath: LPSTR, flags: INT, pfnfdin: PFNFDINOTIFY, pfnfdid: PFNFDIDECRYPT | NULL, pvUser: LPVOID | NULL): BOOL {
+    return Cabinet.Load('FDICopy')(hfdi, pszCabinet, pszCabPath, flags, pfnfdin, pfnfdid, pvUser);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fdicreate
+  public static FDICreate(pfnalloc: PFNALLOC, pfnfree: PFNFREE, pfnopen: PFNOPEN, pfnread: PFNREAD, pfnwrite: PFNWRITE, pfnclose: PFNCLOSE, pfnseek: PFNSEEK, cpuType: INT, perf: PERF): HFDI {
+    return Cabinet.Load('FDICreate')(pfnalloc, pfnfree, pfnopen, pfnread, pfnwrite, pfnclose, pfnseek, cpuType, perf);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fdidestroy
+  public static FDIDestroy(hfdi: HFDI): BOOL {
+    return Cabinet.Load('FDIDestroy')(hfdi);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fdiiscabinet
+  public static FDIIsCabinet(hfdi: HFDI, hf: INT_PTR, pfdici: PFDICABINETINFO): BOOL {
+    return Cabinet.Load('FDIIsCabinet')(hfdi, hf, pfdici);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/fdi/nf-fdi-fditruncatecabinet
+  public static FDITruncateCabinet(hfdi: HFDI, pszCabinetName: LPSTR, iFolderToDelete: USHORT): BOOL {
+    return Cabinet.Load('FDITruncateCabinet')(hfdi, pszCabinetName, iFolderToDelete);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-querycompressorinformation
+  public static QueryCompressorInformation(CompressorHandle: COMPRESSOR_HANDLE, CompressInformationClass: COMPRESS_INFORMATION_CLASS, CompressInformation: PVOID, CompressInformationSize: SIZE_T): BOOL {
+    return Cabinet.Load('QueryCompressorInformation')(CompressorHandle, CompressInformationClass, CompressInformation, CompressInformationSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-querydecompressorinformation
+  public static QueryDecompressorInformation(DecompressorHandle: DECOMPRESSOR_HANDLE, CompressInformationClass: COMPRESS_INFORMATION_CLASS, CompressInformation: PVOID, CompressInformationSize: SIZE_T): BOOL {
+    return Cabinet.Load('QueryDecompressorInformation')(DecompressorHandle, CompressInformationClass, CompressInformation, CompressInformationSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-resetcompressor
+  public static ResetCompressor(CompressorHandle: COMPRESSOR_HANDLE): BOOL {
+    return Cabinet.Load('ResetCompressor')(CompressorHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-resetdecompressor
+  public static ResetDecompressor(DecompressorHandle: DECOMPRESSOR_HANDLE): BOOL {
+    return Cabinet.Load('ResetDecompressor')(DecompressorHandle);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-setcompressorinformation
+  public static SetCompressorInformation(CompressorHandle: COMPRESSOR_HANDLE, CompressInformationClass: COMPRESS_INFORMATION_CLASS, CompressInformation: LPCVOID, CompressInformationSize: SIZE_T): BOOL {
+    return Cabinet.Load('SetCompressorInformation')(CompressorHandle, CompressInformationClass, CompressInformation, CompressInformationSize);
+  }
+
+  // https://learn.microsoft.com/en-us/windows/win32/api/compressapi/nf-compressapi-setdecompressorinformation
+  public static SetDecompressorInformation(DecompressorHandle: DECOMPRESSOR_HANDLE, CompressInformationClass: COMPRESS_INFORMATION_CLASS, CompressInformation: LPCVOID, CompressInformationSize: SIZE_T): BOOL {
+    return Cabinet.Load('SetDecompressorInformation')(DecompressorHandle, CompressInformationClass, CompressInformation, CompressInformationSize);
+  }
+}
+
+export default Cabinet;

package/types/Cabinet.ts

@@ -0,0 +1,101 @@
+import type { Pointer } from 'bun:ffi';
+
+export type { BOOL, DWORD, INT, INT_PTR, LPCVOID, LPSTR, LPVOID, NULL, PVOID, SIZE_T, USHORT, VOID } from '@bun-win32/core';
+
+export const COMPRESS_RAW = 0x2000_0000;
+
+export enum COMPRESS_ALGORITHM {
+  COMPRESS_ALGORITHM_INVALID = 0,
+  COMPRESS_ALGORITHM_LZMS = 5,
+  COMPRESS_ALGORITHM_MAX = 6,
+  COMPRESS_ALGORITHM_MSZIP = 2,
+  COMPRESS_ALGORITHM_NULL = 1,
+  COMPRESS_ALGORITHM_XPRESS = 3,
+  COMPRESS_ALGORITHM_XPRESS_HUFF = 4,
+}
+
+export enum COMPRESS_INFORMATION_CLASS {
+  COMPRESS_INFORMATION_CLASS_BLOCK_SIZE = 1,
+  COMPRESS_INFORMATION_CLASS_INVALID = 0,
+  COMPRESS_INFORMATION_CLASS_LEVEL = 2,
+}
+
+export enum FCIERROR {
+  FCIERR_ALLOC_FAIL = 3,
+  FCIERR_BAD_COMPR_TYPE = 5,
+  FCIERR_CAB_FILE = 6,
+  FCIERR_CAB_FORMAT_LIMIT = 9,
+  FCIERR_MCI_FAIL = 8,
+  FCIERR_NONE = 0,
+  FCIERR_OPEN_SRC = 1,
+  FCIERR_READ_SRC = 2,
+  FCIERR_TEMP_FILE = 4,
+  FCIERR_USER_ABORT = 7,
+}
+
+export enum FDIERROR {
+  FDIERROR_ALLOC_FAIL = 5,
+  FDIERROR_BAD_COMPR_TYPE = 6,
+  FDIERROR_CABINET_NOT_FOUND = 1,
+  FDIERROR_CORRUPT_CABINET = 4,
+  FDIERROR_MDI_FAIL = 7,
+  FDIERROR_NONE = 0,
+  FDIERROR_NOT_A_CABINET = 2,
+  FDIERROR_RESERVE_MISMATCH = 9,
+  FDIERROR_TARGET_FILE = 8,
+  FDIERROR_UNKNOWN_CABINET_VERSION = 3,
+  FDIERROR_USER_ABORT = 11,
+  FDIERROR_WRONG_CABINET = 10,
+}
+
+export enum FDINOTIFICATIONTYPE {
+  fdintCABINET_INFO = 0,
+  fdintCLOSE_FILE_INFO = 3,
+  fdintCOPY_FILE = 2,
+  fdintENUMERATE = 5,
+  fdintNEXT_CABINET = 4,
+  fdintPARTIAL_FILE = 1,
+}
+
+export enum TCOMP_TYPE {
+  tcompTYPE_LZX = 3,
+  tcompTYPE_MSZIP = 1,
+  tcompTYPE_NONE = 0,
+  tcompTYPE_QUANTUM = 2,
+}
+
+export type COMPRESSOR_HANDLE = bigint;
+export type DECOMPRESSOR_HANDLE = bigint;
+export type HFCI = bigint;
+export type HFDI = bigint;
+export type PCABINETDLLVERSIONINFO = Pointer;
+export type PCCAB = Pointer;
+export type PCOMPRESS_ALLOCATION_ROUTINES = Pointer;
+export type PCOMPRESSOR_HANDLE = Pointer;
+export type PDECOMPRESSOR_HANDLE = Pointer;
+export type PERF = Pointer;
+export type PFDICABINETINFO = Pointer;
+export type PFNALLOC = Pointer;
+export type PFNCLOSE = Pointer;
+export type PFNFCIALLOC = Pointer;
+export type PFNFCICLOSE = Pointer;
+export type PFNFCIDELETE = Pointer;
+export type PFNFCIFILEPLACED = Pointer;
+export type PFNFCIFREE = Pointer;
+export type PFNFCIGETNEXTCABINET = Pointer;
+export type PFNFCIGETOPENINFO = Pointer;
+export type PFNFCIGETTEMPFILE = Pointer;
+export type PFNFCIOPEN = Pointer;
+export type PFNFCIREAD = Pointer;
+export type PFNFCISEEK = Pointer;
+export type PFNFCISTATUS = Pointer;
+export type PFNFCIWRITE = Pointer;
+export type PFNFDIDECRYPT = Pointer;
+export type PFNFDINOTIFY = Pointer;
+export type PFNFREE = Pointer;
+export type PFNOPEN = Pointer;
+export type PFNREAD = Pointer;
+export type PFNSEEK = Pointer;
+export type PFNWRITE = Pointer;
+export type PSIZE_T = Pointer;
+export type TCOMP = number;