@ebowwa/bun-native-page 0.2.0

package/dist/allocator.ts

@@ -0,0 +1,334 @@
+/**
+ * High-level allocator classes: PageArena and BufferPool
+ */
+
+import { getPageSize, alignToPage, allocPageAligned, mmapAnonymous, type AllocatedBuffer, type MappedRegion } from './index.js';
+import { PageSizeError } from './errors.js';
+
+// ============================================================================
+// PageArena
+// ============================================================================
+
+export interface ArenaOptions {
+  /** Initial size in bytes */
+  initialSize?: number;
+  /** Growth factor when arena is full (default: 2) */
+  growthFactor?: number;
+  /** Maximum size in bytes (default: 4GB) */
+  maxSize?: number;
+  /** Use huge pages if available (Linux only) */
+  useHugePages?: boolean;
+  /** Lock pages in memory (prevent swap) */
+  lockMemory?: boolean;
+  /** Use mmap instead of malloc (for large arenas) */
+  useMmap?: boolean;
+}
+
+/**
+ * A bump-allocator arena backed by page-aligned memory
+ */
+export class PageArena {
+  private _capacity: number;
+  private _used: number;
+  private _growthFactor: number;
+  private _maxSize: number;
+  private _buffer: AllocatedBuffer | MappedRegion | null;
+  private _useMmap: boolean;
+  private _destroyed: boolean;
+  private _allocations: Array<{ offset: number; size: number }>;
+
+  constructor(options: ArenaOptions = {}) {
+    const pageSize = getPageSize();
+    const initialSize = alignToPage(options.initialSize ?? pageSize.size * 4);
+    this._growthFactor = options.growthFactor ?? 2;
+    this._maxSize = options.maxSize ?? 4 * 1024 * 1024 * 1024; // 4GB
+    this._useMmap = options.useMmap ?? initialSize >= 1024 * 1024; // mmap for >= 1MB
+    this._capacity = initialSize;
+    this._used = 0;
+    this._destroyed = false;
+    this._allocations = [];
+
+    // Allocate initial buffer
+    if (this._useMmap) {
+      this._buffer = mmapAnonymous(initialSize, 'read-write');
+      if (options.lockMemory) {
+        this._buffer.lock();
+      }
+    } else {
+      this._buffer = allocPageAligned(initialSize);
+    }
+  }
+
+  /** Current capacity in bytes */
+  get capacity(): number {
+    return this._capacity;
+  }
+
+  /** Bytes used */
+  get used(): number {
+    return this._used;
+  }
+
+  /** Bytes available */
+  get available(): number {
+    return this._capacity - this._used;
+  }
+
+  /** Get ArrayBuffer view of entire arena */
+  get buffer(): ArrayBuffer {
+    this._checkDestroyed();
+    return this._buffer!.buffer;
+  }
+
+  /**
+   * Allocate bytes, returns offset from arena start
+   */
+  alloc(size: number, alignment: number = 8): number {
+    this._checkDestroyed();
+
+    if (size <= 0) {
+      throw new PageSizeError('Allocation size must be positive');
+    }
+
+    // Align offset to requested alignment (not page size - arena is already page-aligned)
+    const currentOffset = this._used;
+    const alignedOffset = Math.ceil(currentOffset / alignment) * alignment;
+
+    // Check if we need to grow
+    if (alignedOffset + size > this._capacity) {
+      this._grow(alignedOffset + size);
+    }
+
+    this._used = alignedOffset + size;
+    this._allocations.push({ offset: alignedOffset, size });
+
+    return alignedOffset;
+  }
+
+  /**
+   * Get slice at offset
+   */
+  slice(offset: number, length: number): ArrayBuffer {
+    this._checkDestroyed();
+    return this._buffer!.buffer.slice(offset, offset + length);
+  }
+
+  /**
+   * Reset arena (does not free memory, allows reuse)
+   */
+  reset(): void {
+    this._checkDestroyed();
+    this._used = 0;
+    this._allocations = [];
+  }
+
+  /**
+   * Grow arena by at least additionalBytes
+   */
+  grow(additionalBytes: number): void {
+    this._checkDestroyed();
+    this._grow(this._used + additionalBytes);
+  }
+
+  private _grow(requiredSize: number): void {
+    if (requiredSize > this._maxSize) {
+      throw new PageSizeError(`Arena would exceed max size of ${this._maxSize} bytes`);
+    }
+
+    // Calculate new size with growth factor
+    const alignedRequired = alignToPage(requiredSize);
+    const newSize = Math.min(
+      Math.max(alignedRequired, alignToPage(this._capacity * this._growthFactor)),
+      this._maxSize
+    );
+
+    // Allocate new buffer
+    let newBuffer: AllocatedBuffer | MappedRegion;
+    if (this._useMmap) {
+      newBuffer = mmapAnonymous(newSize, 'read-write');
+    } else {
+      const buf = allocPageAligned(newSize);
+      if (!buf) {
+        throw new PageSizeError(`Failed to grow arena to ${newSize} bytes`);
+      }
+      newBuffer = buf;
+    }
+
+    // Copy existing data to new buffer
+    if (this._used > 0 && this._buffer) {
+      const oldView = new Uint8Array(this._buffer.buffer);
+      const newView = new Uint8Array(newBuffer.buffer);
+      newView.set(oldView.subarray(0, this._used));
+    }
+
+    // Free old buffer
+    if (this._buffer) {
+      if ('unmap' in this._buffer) {
+        this._buffer.unmap();
+      } else {
+        this._buffer.free();
+      }
+    }
+
+    // Update references
+    this._buffer = newBuffer;
+    this._capacity = newSize;
+  }
+
+  /**
+   * Free all memory
+   */
+  destroy(): void {
+    if (this._destroyed) return;
+    this._destroyed = true;
+
+    if (this._buffer) {
+      if ('unmap' in this._buffer) {
+        this._buffer.unmap();
+      } else {
+        this._buffer.free();
+      }
+      this._buffer = null;
+    }
+  }
+
+  private _checkDestroyed(): void {
+    if (this._destroyed) {
+      throw new PageSizeError('Arena has been destroyed');
+    }
+  }
+
+  /**
+   * Create arena from existing options
+   */
+  static from(options: ArenaOptions): PageArena {
+    return new PageArena(options);
+  }
+}
+
+// ============================================================================
+// BufferPool
+// ============================================================================
+
+/**
+ * A pool of fixed-size page-aligned buffers
+ */
+export class BufferPool {
+  private _bufferSize: number;
+  private _buffers: AllocatedBuffer[];
+  private _available: AllocatedBuffer[];
+  private _inUse: Set<AllocatedBuffer>;
+  private _destroyed: boolean;
+
+  constructor(bufferSize: number, initialCount: number = 4) {
+    const pageSize = getPageSize();
+    this._bufferSize = alignToPage(bufferSize);
+    this._buffers = [];
+    this._available = [];
+    this._inUse = new Set();
+    this._destroyed = false;
+
+    // Pre-allocate initial buffers
+    for (let i = 0; i < initialCount; i++) {
+      const buffer = allocPageAligned(this._bufferSize);
+      if (buffer) {
+        this._buffers.push(buffer);
+        this._available.push(buffer);
+      }
+    }
+  }
+
+  /** Individual buffer size */
+  get bufferSize(): number {
+    return this._bufferSize;
+  }
+
+  /** Total buffers in pool */
+  get totalCount(): number {
+    return this._buffers.length;
+  }
+
+  /** Available buffers */
+  get availableCount(): number {
+    return this._available.length;
+  }
+
+  /** In-use buffers */
+  get inUseCount(): number {
+    return this._inUse.size;
+  }
+
+  /**
+   * Acquire a buffer from the pool
+   */
+  acquire(): AllocatedBuffer {
+    this._checkDestroyed();
+
+    let buffer: AllocatedBuffer | undefined;
+
+    if (this._available.length > 0) {
+      buffer = this._available.pop();
+    } else {
+      // Grow pool
+      buffer = allocPageAligned(this._bufferSize);
+      if (!buffer) {
+        throw new PageSizeError('Failed to allocate buffer from pool');
+      }
+      this._buffers.push(buffer);
+    }
+
+    this._inUse.add(buffer!);
+    return buffer!;
+  }
+
+  /**
+   * Return a buffer to the pool
+   */
+  release(buffer: AllocatedBuffer): void {
+    this._checkDestroyed();
+
+    if (!this._inUse.has(buffer)) {
+      throw new PageSizeError('Buffer does not belong to this pool or already released');
+    }
+
+    this._inUse.delete(buffer);
+    this._available.push(buffer);
+  }
+
+  /**
+   * Grow pool by count
+   */
+  grow(count: number): void {
+    this._checkDestroyed();
+
+    for (let i = 0; i < count; i++) {
+      const buffer = allocPageAligned(this._bufferSize);
+      if (buffer) {
+        this._buffers.push(buffer);
+        this._available.push(buffer);
+      }
+    }
+  }
+
+  /**
+   * Destroy pool and free all memory
+   */
+  destroy(): void {
+    if (this._destroyed) return;
+    this._destroyed = true;
+
+    for (const buffer of this._buffers) {
+      buffer.free();
+    }
+
+    this._buffers = [];
+    this._available = [];
+    this._inUse.clear();
+  }
+
+  private _checkDestroyed(): void {
+    if (this._destroyed) {
+      throw new PageSizeError('BufferPool has been destroyed');
+    }
+  }
+}

package/dist/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Error types for @ebowwa/bun-native-page
+ */
+export declare class PageSizeError extends Error {
+    constructor(message: string);
+}
+export declare class AllocationError extends PageSizeError {
+    size: number;
+    constructor(size: number, reason: string);
+}
+export declare class MapError extends PageSizeError {
+    size: number;
+    constructor(size: number, reason: string);
+}
+export declare class UnmapError extends PageSizeError {
+    constructor(reason: string);
+}
+export declare class ProtectionError extends PageSizeError {
+    constructor(reason: string);
+}
+export declare class LockError extends PageSizeError {
+    constructor(reason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,eAAgB,SAAQ,aAAa;IAEvC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM;CAKjB;AAED,qBAAa,QAAS,SAAQ,aAAa;IAEhC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM;CAKjB;AAED,qBAAa,UAAW,SAAQ,aAAa;gBAC/B,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,eAAgB,SAAQ,aAAa;gBACpC,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,SAAU,SAAQ,aAAa;gBAC9B,MAAM,EAAE,MAAM;CAI3B"}

package/dist/errors.js

@@ -0,0 +1,44 @@
+/**
+ * Error types for @ebowwa/bun-native-page
+ */
+export class PageSizeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PageSizeError';
+    }
+}
+export class AllocationError extends PageSizeError {
+    size;
+    constructor(size, reason) {
+        super(`Failed to allocate ${size} bytes: ${reason}`);
+        this.size = size;
+        this.name = 'AllocationError';
+    }
+}
+export class MapError extends PageSizeError {
+    size;
+    constructor(size, reason) {
+        super(`Failed to map ${size} bytes: ${reason}`);
+        this.size = size;
+        this.name = 'MapError';
+    }
+}
+export class UnmapError extends PageSizeError {
+    constructor(reason) {
+        super(`Failed to unmap memory: ${reason}`);
+        this.name = 'UnmapError';
+    }
+}
+export class ProtectionError extends PageSizeError {
+    constructor(reason) {
+        super(`Failed to change protection: ${reason}`);
+        this.name = 'ProtectionError';
+    }
+}
+export class LockError extends PageSizeError {
+    constructor(reason) {
+        super(`Failed to lock memory: ${reason}`);
+        this.name = 'LockError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,OAAO,aAAc,SAAQ,KAAK;IACtC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AAED,MAAM,OAAO,eAAgB,SAAQ,aAAa;IAEvC;IADT,YACS,IAAY,EACnB,MAAc;QAEd,KAAK,CAAC,sBAAsB,IAAI,WAAW,MAAM,EAAE,CAAC,CAAC;QAH9C,SAAI,GAAJ,IAAI,CAAQ;QAInB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AAED,MAAM,OAAO,QAAS,SAAQ,aAAa;IAEhC;IADT,YACS,IAAY,EACnB,MAAc;QAEd,KAAK,CAAC,iBAAiB,IAAI,WAAW,MAAM,EAAE,CAAC,CAAC;QAHzC,SAAI,GAAJ,IAAI,CAAQ;QAInB,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;IACzB,CAAC;CACF;AAED,MAAM,OAAO,UAAW,SAAQ,aAAa;IAC3C,YAAY,MAAc;QACxB,KAAK,CAAC,2BAA2B,MAAM,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,OAAO,eAAgB,SAAQ,aAAa;IAChD,YAAY,MAAc;QACxB,KAAK,CAAC,gCAAgC,MAAM,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AAED,MAAM,OAAO,SAAU,SAAQ,aAAa;IAC1C,YAAY,MAAc;QACxB,KAAK,CAAC,0BAA0B,MAAM,EAAE,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC;IAC1B,CAAC;CACF"}

package/dist/errors.ts

@@ -0,0 +1,51 @@
+/**
+ * Error types for @ebowwa/bun-native-page
+ */
+
+export class PageSizeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PageSizeError';
+  }
+}
+
+export class AllocationError extends PageSizeError {
+  constructor(
+    public size: number,
+    reason: string
+  ) {
+    super(`Failed to allocate ${size} bytes: ${reason}`);
+    this.name = 'AllocationError';
+  }
+}
+
+export class MapError extends PageSizeError {
+  constructor(
+    public size: number,
+    reason: string
+  ) {
+    super(`Failed to map ${size} bytes: ${reason}`);
+    this.name = 'MapError';
+  }
+}
+
+export class UnmapError extends PageSizeError {
+  constructor(reason: string) {
+    super(`Failed to unmap memory: ${reason}`);
+    this.name = 'UnmapError';
+  }
+}
+
+export class ProtectionError extends PageSizeError {
+  constructor(reason: string) {
+    super(`Failed to change protection: ${reason}`);
+    this.name = 'ProtectionError';
+  }
+}
+
+export class LockError extends PageSizeError {
+  constructor(reason: string) {
+    super(`Failed to lock memory: ${reason}`);
+    this.name = 'LockError';
+  }
+}

package/dist/ffi.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Bun FFI bindings to page_native library
+ */
+import { ptr, toArrayBuffer } from 'bun:ffi';
+export declare const ffi: {
+    getSize: {
+        (): bigint;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    is4k: {
+        (): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    is16k: {
+        (): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    getHugePageSize: {
+        (): bigint;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    getPlatform: {
+        (): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    alignSize: {
+        (args_0: number | bigint): bigint;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    truncateSize: {
+        (args_0: number | bigint): bigint;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    isAligned: {
+        (args_0: number | bigint): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    alloc: {
+        (args_0: number | bigint): import("bun:ffi").Pointer;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    allocPtr: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString): import("bun:ffi").Pointer;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    allocSize: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString): bigint;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    free: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString): undefined;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mmapAnonymous: {
+        (args_0: number | bigint, args_1: number): import("bun:ffi").Pointer;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mmapFile: {
+        (args_0: number, args_1: number | bigint, args_2: number | bigint, args_3: number): import("bun:ffi").Pointer;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mmapHuge: {
+        (args_0: number | bigint): import("bun:ffi").Pointer;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mmapPtr: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString): import("bun:ffi").Pointer;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mmapSize: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString): bigint;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    munmap: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    madvise: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_1: number | bigint, args_2: number): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mprotect: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_1: number | bigint, args_2: number): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    mlock: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_1: number | bigint): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    munlock: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_1: number | bigint): number;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    zero: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_1: number | bigint): undefined;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+    copy: {
+        (args_0: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_1: NodeJS.TypedArray<ArrayBufferLike> | import("bun:ffi").Pointer | import("bun:ffi").CString, args_2: number | bigint): undefined;
+        __ffi_function_callable: typeof import("bun:ffi").FFIFunctionCallableSymbol;
+    };
+};
+export { ptr, toArrayBuffer };
+//# sourceMappingURL=ffi.d.ts.map

package/dist/ffi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ffi.d.ts","sourceRoot":"","sources":["ffi.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAkB,GAAG,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAgF7D,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCf,CAAC;AAEF,OAAO,EAAE,GAAG,EAAE,aAAa,EAAE,CAAC"}

package/dist/ffi.js

@@ -0,0 +1,102 @@
+/**
+ * Bun FFI bindings to page_native library
+ */
+import { dlopen, ptr, toArrayBuffer } from 'bun:ffi';
+// Platform detection
+const platform = process.platform;
+const arch = process.arch;
+// Resolve native library path
+function getNativePath() {
+    const platformMap = {
+        'darwin-arm64': 'darwin-arm64',
+        'darwin-x64': 'darwin-x64',
+        'linux-x64': 'linux-x64',
+        'linux-x86': 'linux-x86',
+        'linux-arm64': 'linux-arm64',
+        'linux-arm': 'linux-arm',
+        'win32-x64': 'windows-x64',
+        'win32-x86': 'windows-x86',
+        'win32-arm64': 'windows-arm64',
+    };
+    const key = `${platform}-${arch}`;
+    const platformDir = platformMap[key];
+    if (!platformDir) {
+        throw new Error(`Unsupported platform: ${key}`);
+    }
+    const libName = platform === 'win32' ? 'page_native.dll' : `libpage_native.dylib`;
+    return import.meta.dir + `/../native/${platformDir}/${libName}`;
+}
+// FFI symbol definitions
+const symbols = {
+    // Page size
+    page_get_size: { returns: 'usize' },
+    page_is_4k: { returns: 'i32' },
+    page_is_16k: { returns: 'i32' },
+    page_get_huge_page_size: { returns: 'usize' },
+    page_get_platform: { returns: 'i32' },
+    page_align_size: { args: ['usize'], returns: 'usize' },
+    page_truncate_size: { args: ['usize'], returns: 'usize' },
+    page_is_aligned: { args: ['usize'], returns: 'i32' },
+    // Allocation
+    page_alloc: { args: ['usize'], returns: 'pointer' },
+    page_alloc_ptr: { args: ['pointer'], returns: 'pointer' },
+    page_alloc_size: { args: ['pointer'], returns: 'usize' },
+    page_free: { args: ['pointer'], returns: 'void' },
+    // mmap
+    page_mmap_anonymous: { args: ['usize', 'i32'], returns: 'pointer' },
+    page_mmap_file: { args: ['i32', 'usize', 'i64', 'i32'], returns: 'pointer' },
+    page_mmap_huge: { args: ['usize'], returns: 'pointer' },
+    page_mmap_ptr: { args: ['pointer'], returns: 'pointer' },
+    page_mmap_size: { args: ['pointer'], returns: 'usize' },
+    page_munmap: { args: ['pointer'], returns: 'i32' },
+    page_madvise: { args: ['ptr', 'usize', 'i32'], returns: 'i32' },
+    page_mprotect: { args: ['ptr', 'usize', 'i32'], returns: 'i32' },
+    page_mlock: { args: ['ptr', 'usize'], returns: 'i32' },
+    page_munlock: { args: ['ptr', 'usize'], returns: 'i32' },
+    // Utility
+    page_zero: { args: ['ptr', 'usize'], returns: 'void' },
+    page_copy: { args: ['ptr', 'ptr', 'usize'], returns: 'void' },
+};
+// Load the library
+let lib;
+try {
+    lib = dlopen(getNativePath(), symbols);
+}
+catch (e) {
+    throw new Error(`Failed to load page_native library for ${platform}-${arch}. ` +
+        `Make sure the native library is built for your platform. ` +
+        `Error: ${e}`);
+}
+// Export the FFI functions
+export const ffi = {
+    // Page size
+    getSize: lib.symbols.page_get_size,
+    is4k: lib.symbols.page_is_4k,
+    is16k: lib.symbols.page_is_16k,
+    getHugePageSize: lib.symbols.page_get_huge_page_size,
+    getPlatform: lib.symbols.page_get_platform,
+    alignSize: lib.symbols.page_align_size,
+    truncateSize: lib.symbols.page_truncate_size,
+    isAligned: lib.symbols.page_is_aligned,
+    // Allocation
+    alloc: lib.symbols.page_alloc,
+    allocPtr: lib.symbols.page_alloc_ptr,
+    allocSize: lib.symbols.page_alloc_size,
+    free: lib.symbols.page_free,
+    // mmap
+    mmapAnonymous: lib.symbols.page_mmap_anonymous,
+    mmapFile: lib.symbols.page_mmap_file,
+    mmapHuge: lib.symbols.page_mmap_huge,
+    mmapPtr: lib.symbols.page_mmap_ptr,
+    mmapSize: lib.symbols.page_mmap_size,
+    munmap: lib.symbols.page_munmap,
+    madvise: lib.symbols.page_madvise,
+    mprotect: lib.symbols.page_mprotect,
+    mlock: lib.symbols.page_mlock,
+    munlock: lib.symbols.page_munlock,
+    // Utility
+    zero: lib.symbols.page_zero,
+    copy: lib.symbols.page_copy,
+};
+export { ptr, toArrayBuffer };
+//# sourceMappingURL=ffi.js.map

package/dist/ffi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ffi.js","sourceRoot":"","sources":["ffi.ts"],"names":[],"mappings":"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"}