@php-wasm/node 3.0.54 → 3.1.0

package/lib/file-lock-manager-for-posix.d.ts

@@ -0,0 +1,14 @@
+import type { FileLockManager, WholeFileLockOp, RequestedRangeLock, Path } from '@php-wasm/universal';
+type StoredWholeFileLock = WholeFileLockOp & {
+    path: Path;
+};
+export declare class FileLockManagerForPosix implements FileLockManager {
+    wholeFileLockMap: Map<number, Map<number, StoredWholeFileLock>>;
+    rangeLockedFds: Map<number, Map<string, Set<number>>>;
+    lockWholeFile(path: string, op: WholeFileLockOp): boolean;
+    lockFileByteRange(path: string, op: RequestedRangeLock, waitForLock: boolean): boolean;
+    findFirstConflictingByteRangeLock(path: string, op: RequestedRangeLock): ReturnType<FileLockManager['findFirstConflictingByteRangeLock']>;
+    releaseLocksForProcess(targetPid: number): void;
+    releaseLocksOnFdClose(targetPid: number, targetFd: number, targetPath: string): void;
+}
+export {};

package/lib/file-lock-manager-for-windows.d.ts

@@ -0,0 +1,15 @@
+import type { FileLockManager, WholeFileLockOp, RequestedRangeLock, Path } from '@php-wasm/universal';
+import { FileLockIntervalTree } from '@php-wasm/universal';
+type StoredWholeFileLock = WholeFileLockOp & {
+    path: Path;
+};
+export declare class FileLockManagerForWindows implements FileLockManager {
+    wholeFileLockMap: Map<number, Map<number, StoredWholeFileLock>>;
+    rangeLockedFds: Map<string, FileLockIntervalTree>;
+    lockWholeFile(path: string, op: WholeFileLockOp): boolean;
+    lockFileByteRange(path: string, op: RequestedRangeLock, waitForLock: boolean): boolean;
+    findFirstConflictingByteRangeLock(path: string, op: RequestedRangeLock): ReturnType<FileLockManager['findFirstConflictingByteRangeLock']>;
+    releaseLocksForProcess(targetPid: number): void;
+    releaseLocksOnFdClose(targetPid: number, targetFd: number, targetPath: string): void;
+}
+export {};

package/lib/index.d.ts

@@ -3,6 +3,8 @@ export * from './networking/with-networking';
 export * from './load-runtime';
 export * from './use-host-filesystem';
 export * from './node-fs-mount';
-export * from './file-lock-manager';
-export * from './file-lock-manager-for-node';
+export * from './file-lock-manager-for-posix';
+export * from './file-lock-manager-for-windows';
 export * from './extensions/xdebug/with-xdebug';
+export * from './wasm-user-space';
+export * from './wasm-kernel-space';

package/lib/load-runtime.d.ts

@@ -1,9 +1,7 @@
-import type { SupportedPHPVersion, EmscriptenOptions, RemoteAPI } from '@php-wasm/universal';
-import type { FileLockManager } from './file-lock-manager';
+import { type SupportedPHPVersion, type EmscriptenOptions, type FileLockManager } from '@php-wasm/universal';
+import type { WasmUserSpaceAPI, WasmUserSpaceContext } from './wasm-user-space';
 import { type XdebugOptions } from './extensions/xdebug/with-xdebug';
-import type { Promised } from '@php-wasm/util';
 export interface PHPLoaderOptions {
-    emscriptenOptions?: EmscriptenOptions;
     followSymlinks?: boolean;
     withXdebug?: boolean;
     xdebug?: XdebugOptions;
@@ -12,6 +10,11 @@ export interface PHPLoaderOptions {
     withMemcached?: boolean;
 }
 export type PHPLoaderOptionsForNode = PHPLoaderOptions & {
+    /**
+     * A file lock manager to coordinate file locks between
+     * multiple php-wasm instances and other OS processes.
+     */
+    fileLockManager?: FileLockManager;
     emscriptenOptions?: EmscriptenOptions & {
         /**
          * The process ID for the PHP runtime.
@@ -23,15 +26,13 @@ export type PHPLoaderOptionsForNode = PHPLoaderOptions & {
          */
         processId?: number;
         /**
-         * An optional file lock manager to use for the PHP runtime.
-         *
-         * The lock manager is optional when running a single php-wasm process.
-         *
-         * When running with JSPI, both synchronous and asynchronous
-         * file lock managers are supported.
-         * When running with Asyncify, the file lock manager must be synchronous.
+         * Factory called during WASM initialization to create
+         * user-space syscall implementations (flock, fcntl, etc.)
+         * for a PHP process. Receives process context (PID,
+         * constants, errno codes) and returns the bound syscall
+         * functions.
          */
-        fileLockManager?: RemoteAPI<FileLockManager> | Promised<FileLockManager> | FileLockManager;
+        bindUserSpace?: (userSpaceContext: WasmUserSpaceContext) => WasmUserSpaceAPI;
         /**
          * An optional function to collect trace messages.
          *
@@ -41,16 +42,10 @@ export type PHPLoaderOptionsForNode = PHPLoaderOptions & {
          */
         trace?: (processId: number, format: string, ...args: any[]) => void;
         /**
-         * An optional object to pass to the PHP-WASM library's `init` function.
-         *
-         * phpWasmInitOptions.nativeInternalDirPath is used to mount a
-         * real, native directory as the php-wasm /internal directory.
-         *
-         * @see https://github.com/php-wasm/php-wasm/blob/main/compile/php/phpwasm-emscripten-library.js#L100
+         * An optional path used to a real, native directory
+         * to be mounted as the php-wasm /internal directory.
          */
-        phpWasmInitOptions?: {
-            nativeInternalDirPath?: string;
-        };
+        nativeInternalDirPath?: string;
     };
 };
 /**

package/lib/wasm-kernel-space.d.ts

@@ -0,0 +1,9 @@
+import type { FileLockManager } from '@php-wasm/universal';
+/**
+ * Shared state that persists across all PHP-WASM processes, analogous
+ * to OS kernel space. Currently holds the file lock manager that
+ * coordinates locks across PHP-WASM instances.
+ */
+export type WasmKernelSpace = {
+    readonly fileLockManager: FileLockManager | undefined;
+};

package/lib/wasm-user-space.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Per-process syscall implementations (flock, fcntl, etc.) that run
+ * in the context of a single WASM PHP process. Analogous to OS
+ * user space: each process gets its own instance bound to its PID,
+ * constants, and file descriptor table.
+ */
+import type { Emscripten } from '@php-wasm/universal';
+import type { WasmKernelSpace } from './wasm-kernel-space';
+type FSNode = Emscripten.FS.FSNode;
+type NonZeroNumber = Exclude<number, 0>;
+export type WasmUserSpaceContext = {
+    pid: number;
+    constants: {
+        F_RDLCK: number;
+        F_WRLCK: number;
+        F_UNLCK: number;
+        F_GETFL: number;
+        O_ACCMODE: number;
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_APPEND: number;
+        O_NONBLOCK: number;
+        F_SETFL: number;
+        F_GETLK: number;
+        F_SETLK: number;
+        F_SETLKW: number;
+        SEEK_SET: number;
+        SEEK_CUR: number;
+        SEEK_END: number;
+        LOCK_SH: 1;
+        LOCK_EX: 2;
+        LOCK_NB: 4;
+        LOCK_UN: 8;
+    };
+    errnoCodes: {
+        EBADF: NonZeroNumber;
+        EINVAL: NonZeroNumber;
+        EAGAIN: NonZeroNumber;
+        EDEADLK: NonZeroNumber;
+        EWOULDBLOCK: NonZeroNumber;
+    };
+    memory: {
+        HEAP8: Int8Array;
+        HEAPU8: Uint8Array;
+        HEAP16: Int16Array;
+        HEAPU16: Uint16Array;
+        HEAP32: Int32Array;
+        HEAPU32: Uint32Array;
+        HEAPF32: Float32Array;
+        HEAP64: BigInt64Array;
+        HEAPU64: BigUint64Array;
+        HEAPF64: Float64Array;
+    };
+    wasmImports: {
+        builtin_fcntl64: (fd: number, cmd: number, varargs?: any) => number;
+        builtin_fd_close: (fd: number) => number;
+        js_wasm_trace: (...args: any[]) => void;
+    };
+    wasmExports: {
+        wasm_get_end_offset: (fd: number) => bigint;
+    };
+    syscalls: {
+        getStreamFromFD: (fd: number) => Emscripten.FS.FSStream;
+    };
+    FS: typeof Emscripten.FS;
+    PROXYFS: typeof Emscripten.PROXYFS & {
+        realPath(node: FSNode): string;
+    };
+    NODEFS: typeof Emscripten.NODEFS & {
+        realPath(node: FSNode): string;
+    };
+};
+export type WasmUserSpaceAPI = {
+    fcntl64: (fd: number, cmd: number, varargs?: number) => number;
+    flock: (fd: number, op: number) => number;
+    fd_close: (fd: number) => number;
+    js_release_file_locks: () => void;
+    gethostbyname: (hostname: string) => Promise<string>;
+};
+export declare function bindUserSpace({ fileLockManager }: WasmKernelSpace, { pid, memory: { HEAP16, HEAP64, HEAP32 }, constants: { F_RDLCK, F_WRLCK, F_UNLCK, F_GETFL, O_ACCMODE, O_RDONLY, O_WRONLY, O_APPEND, O_NONBLOCK, F_SETFL, F_GETLK, F_SETLK, F_SETLKW, SEEK_SET, SEEK_CUR, SEEK_END, LOCK_SH, LOCK_EX, LOCK_NB, LOCK_UN, }, errnoCodes: { EBADF, EINVAL, EAGAIN, EWOULDBLOCK }, wasmImports: { builtin_fcntl64, builtin_fd_close, js_wasm_trace }, wasmExports: { wasm_get_end_offset }, syscalls: { getStreamFromFD }, FS, PROXYFS, NODEFS, }: WasmUserSpaceContext): WasmUserSpaceAPI;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@php-wasm/node",
-  "version": "3.0.54",
+  "version": "3.1.0",
   "description": "PHP.wasm for Node.js",
   "repository": {
     "type": "git",
@@ -38,29 +38,30 @@
   },
   "license": "GPL-2.0-or-later",
   "types": "index.d.ts",
-  "gitHead": "e449793042bf2c66f8fdd4212ef266801ae3f605",
+  "gitHead": "be66d7e27ea9a8f09c2cc15e4470a6e28def5c58",
   "engines": {
     "node": ">=20.10.0",
     "npm": ">=10.2.3"
   },
   "dependencies": {
     "express": "4.22.0",
+    "fs-ext-extra-prebuilt": "2.2.7",
     "ini": "4.1.2",
     "wasm-feature-detect": "1.8.0",
     "ws": "8.18.3",
     "yargs": "17.7.2",
-    "@php-wasm/node-polyfills": "3.0.54",
-    "@php-wasm/universal": "3.0.54",
-    "@php-wasm/node-8-5": "3.0.54",
-    "@php-wasm/node-8-4": "3.0.54",
-    "@php-wasm/node-8-3": "3.0.54",
-    "@php-wasm/node-8-2": "3.0.54",
-    "@php-wasm/node-8-1": "3.0.54",
-    "@php-wasm/node-8-0": "3.0.54",
-    "@php-wasm/node-7-4": "3.0.54",
-    "@php-wasm/logger": "3.0.54",
-    "@php-wasm/util": "3.0.54",
-    "@wp-playground/common": "3.0.54"
+    "@php-wasm/node-polyfills": "3.1.0",
+    "@php-wasm/universal": "3.1.0",
+    "@php-wasm/node-8-5": "3.1.0",
+    "@php-wasm/node-8-4": "3.1.0",
+    "@php-wasm/node-8-3": "3.1.0",
+    "@php-wasm/node-8-2": "3.1.0",
+    "@php-wasm/node-8-1": "3.1.0",
+    "@php-wasm/node-8-0": "3.1.0",
+    "@php-wasm/node-7-4": "3.1.0",
+    "@php-wasm/logger": "3.1.0",
+    "@php-wasm/util": "3.1.0",
+    "@wp-playground/common": "3.1.0"
   },
   "packageManager": "npm@10.9.2",
   "overrides": {
@@ -74,8 +75,5 @@
     "form-data": "^4.0.4",
     "lodash": "^4.17.23",
     "glob": "^9.3.0"
-  },
-  "optionalDependencies": {
-    "fs-ext": "2.1.1"
   }
 }

package/test/file-lock-manager-composite-with-posix--test-process.d.ts

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

package/test/file-lock-manager-composite-with-posix--test-worker-thread.d.ts

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

package/test/file-lock-manager-composite-with-windows--test-process.d.ts

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

package/test/file-lock-manager-composite-with-windows--test-worker-thread.d.ts

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

package/test/file-lock-manager-for-posix--test-process.d.ts

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

package/test/file-lock-manager-for-windows--test-process.d.ts

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

package/test/file-lock-manager-test-utils.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { closeSync, openSync } from 'fs';
+import { type FileLockManager, type RequestedRangeLock } from '@php-wasm/universal';
+export type RequestedRangeLockWithNonBigIntAddresses = Omit<RequestedRangeLock, 'start' | 'end'> & {
+    start: number;
+    end: number;
+};
+export type TestWorkerAPI = Omit<FileLockManager, 'lockFileByteRange' | 'findFirstConflictingByteRangeLock'> & {
+    lockFileByteRange: (path: string, requestedLock: RequestedRangeLockWithNonBigIntAddresses, waitForLock: boolean) => boolean;
+    findFirstConflictingByteRangeLock: (path: string, requestedLock: RequestedRangeLockWithNonBigIntAddresses) => Omit<RequestedRangeLockWithNonBigIntAddresses, 'fd'> | undefined;
+    openSync: typeof openSync;
+    closeSync: typeof closeSync;
+};
+/**
+ * Create a remote process API for a file lock manager.
+ *
+ * @param fileLockManager - The file lock manager to create a remote process API for.
+ * @returns An API for the remote test process to expose.
+ */
+export declare function createRemoteProcessAPIFromFileLockManager(fileLockManager: FileLockManager): TestWorkerAPI;

package/test/file-lock-manager-tests.d.ts

@@ -0,0 +1,6 @@
+export declare function declareFileLockManagerTests({ name, testWorkerUrl, shouldSkip, workerType, }: {
+    name: string;
+    testWorkerUrl: URL;
+    shouldSkip?: boolean;
+    workerType: 'childProcess' | 'workerThread';
+}): import("vitest").SuiteCollector<object>;

package/lib/file-lock-manager-for-node.d.ts

@@ -1,164 +0,0 @@
-type NativeFlockSync = (fd: number, flags: 'sh' | 'ex' | 'shnb' | 'exnb' | 'un') => void;
-import type { FileLockManager, RequestedRangeLock, WholeFileLock, WholeFileLockOp, Pid, Fd } from './file-lock-manager';
-/**
- * This is the file lock manager for use within JS runtimes like Node.js.
- *
- * A FileLockManagerForNode is a wrapper around a Map of FileLock instances.
- * It provides methods for locking and unlocking files, as well as finding conflicting locks.
- */
-export declare class FileLockManagerForNode implements FileLockManager {
-    nativeFlockSync: NativeFlockSync;
-    locks: Map<string, FileLock>;
-    /**
-     * Create a new FileLockManagerForNode instance.
-     *
-     * @param nativeFlockSync A synchronous flock() function to lock files via the host OS.
-     */
-    constructor(nativeFlockSync?: NativeFlockSync);
-    /**
-     * Lock the whole file.
-     *
-     * @param path The path to the file to lock. This should be the path
-     *             of the file in the native filesystem.
-     * @param op The whole file lock operation to perform.
-     * @returns True if the lock was granted, false otherwise.
-     */
-    lockWholeFile(path: string, op: WholeFileLockOp): boolean;
-    /**
-     * Lock a byte range.
-     *
-     * @param path The path to the file to lock. This should be the path
-     *             of the file in the native filesystem.
-     * @param requestedLock The byte range lock to perform.
-     * @returns True if the lock was granted, false otherwise.
-     */
-    lockFileByteRange(path: string, requestedLock: RequestedRangeLock): boolean;
-    /**
-     * Find the first conflicting byte range lock.
-     *
-     * @param path The path to the file to find the conflicting lock for.
-     * @param desiredLock The desired byte range lock.
-     * @returns The first conflicting byte range lock, or undefined if no conflicting lock exists.
-     */
-    findFirstConflictingByteRangeLock(path: string, desiredLock: RequestedRangeLock): Omit<RequestedRangeLock, 'fd'> | undefined;
-    /**
-     * Release all locks for the given process.
-     *
-     * @param pid The process ID to release locks for.
-     */
-    releaseLocksForProcess(pid: number): void;
-    /**
-     * Release all locks for the given process and file descriptor.
-     *
-     * @param pid The process ID to release locks for.
-     * @param fd The file descriptor to release locks for.
-     * @param path The path to the file to release locks for.
-     */
-    releaseLocksForProcessFd(pid: number, fd: number, nativePath: string): void;
-    /**
-     * Forget the path if it is unlocked.
-     *
-     * @param path The path to the file to forget.
-     */
-    private forgetPathIfUnlocked;
-}
-/**
- * A FileLock instance encapsulates a native whole-file lock and file locking between
- * php-wasm processes.
- *
- * A FileLock supports php-wasm whole-file locks and byte range locks.
- * Before granting a php-wasm lock, a FileLock ensures that it first holds a compatible
- * native lock. If a compatible native lock cannot be acquired, the php-wasm lock is
- * not granted.
- */
-export declare class FileLock {
-    /**
-     * Create a new FileLock instance for the given file and mode.
-     * Fail if the underlying native file lock cannot be acquired.
-     *
-     * @param path The path to the file to lock
-     * @param mode The type of lock to acquire
-     * @returns A FileLock instance if the lock was acquired, undefined otherwise
-     */
-    static maybeCreate(path: string, mode: Exclude<WholeFileLock['type'], 'unlocked'>, nativeFlockSync: NativeFlockSync): FileLock | undefined;
-    private nativeLock;
-    private wholeFileLock;
-    private rangeLocks;
-    private constructor();
-    /**
-     * Close the file descriptor and release the native lock.
-     *
-     * @TODO Replace this with a Symbol.dispose property once supported by all JS runtimes.
-     */
-    dispose(): void;
-    /**
-     * Lock the whole file.
-     *
-     * This method corresponds to the flock() function.
-     *
-     * @param op The whole file lock operation to perform.
-     * @returns True if the lock was granted, false otherwise.
-     */
-    lockWholeFile(op: WholeFileLockOp): boolean;
-    /**
-     * Lock a byte range.
-     *
-     * This method corresponds to the fcntl() F_SETLK command.
-     *
-     * @param requestedLock The byte range lock to perform.
-     * @returns True if the lock was granted, false otherwise.
-     */
-    lockFileByteRange(requestedLock: RequestedRangeLock): boolean;
-    /**
-     * Find the first conflicting byte range lock.
-     *
-     * This method corresponds to the fcntl() F_GETLK command.
-     *
-     * @param desiredLock The desired byte range lock.
-     * @returns The first conflicting byte range lock, or undefined if no conflicting lock exists.
-     */
-    findFirstConflictingByteRangeLock(desiredLock: RequestedRangeLock): RequestedRangeLock | undefined;
-    /**
-     * Release all locks for the given process.
-     *
-     * @param pid The process ID to release locks for.
-     */
-    releaseLocksForProcess(pid: Pid): void;
-    /**
-     * Release all locks for the given process and file descriptor.
-     *
-     * @param pid The process ID to release locks for.
-     * @param fd The file descriptor to release locks for.
-     */
-    releaseLocksForProcessFd(pid: Pid, fd: Fd): void;
-    /**
-     * Check if the file lock is unlocked.
-     *
-     * @returns True if the file lock is unlocked, false otherwise.
-     */
-    isUnlocked(): boolean;
-    /**
-     * Ensure that the native lock is compatible with the php-wasm lock,
-     * upgrading or downgrading as needed.
-     *
-     * @param overrideWholeFileLockType If provided, use this type for the whole file lock.
-     * @param overrideRangeLockType If provided, use this type for the range lock.
-     * @returns True if the native lock was upgraded or downgraded, false otherwise.
-     */
-    private ensureCompatibleNativeLock;
-    /**
-     * Check if a lock exists that conflicts with the requested range lock.
-     *
-     * @param requestedLock The desired byte range lock.
-     * @returns True if a conflicting lock exists, false otherwise.
-     */
-    private isThereAConflictWithRequestedRangeLock;
-    /**
-     * Check if a lock exists that conflicts with the requested whole-file lock.
-     *
-     * @param requestedLock The desired whole-file lock.
-     * @returns True if a conflicting lock exists, false otherwise.
-     */
-    private isThereAConflictWithRequestedWholeFileLock;
-}
-export {};

package/lib/file-lock-manager.d.ts

@@ -1,96 +0,0 @@
-/**
- * This is an interface used to abstract byte range locking like fcntl()
- * and whole-file locking like flock().
- */
-export type FileLockManager = {
-    /**
-     * Update the lock on the whole file.
-     *
-     * This method is for updating the lock on the whole file with the F_SETLKW fcntl() command.
-     * https://sourceware.org/glibc/manual/2.41/html_node/File-Locks.html#index-F_005fSETLKW-1
-     *
-     * @param path - The path of the file to lock. This should be the path of the file in the
-     *               underlying filesystem.
-     * @param op - The operation to perform, including 'shared', 'exclusive', or 'unlock'.
-     * @returns A promise for a boolean value.
-     */
-    lockWholeFile: (path: string, op: WholeFileLockOp) => boolean;
-    /**
-     * Update the lock on a byte range of a file.
-     *
-     * This method is for locking with the F_SETLK fcntl() command.
-     * https://sourceware.org/glibc/manual/2.41/html_node/File-Locks.html#index-F_005fSETLK-1
-     *
-     * @param path - The path of the file to lock. This should be the path of the file in the
-     *               underlying filesystem.
-     * @param requestedLock - The lock to request, including start, end, type, and pid.
-     * @returns A promise for a boolean value.
-     *          When locking: True if the lock was acquired, false if it was not.
-     *          When unlocking: Always true.
-     */
-    lockFileByteRange: (path: string, requestedLock: RequestedRangeLock) => boolean;
-    /**
-     * Get the first lock that would conflict with the specified lock.
-     *
-     * This method is meant to satisfy the needs of the F_GETLK fcntl() command.
-     * https://sourceware.org/glibc/manual/2.41/html_node/File-Locks.html#index-F_005fGETLK-1
-     *
-     * @param path - The path of the file to check for conflicts. This should be the path
-     *               of the file in the underlying filesystem.
-     * @param desiredLock - The lock to check for conflicts.
-     * @returns A promise for the first conflicting lock,
-     *          or undefined if there is no conflict.
-     */
-    findFirstConflictingByteRangeLock: (path: string, desiredLock: RequestedRangeLock) => Omit<RequestedRangeLock, 'fd'> | undefined;
-    /**
-     * Release all locks for a given process.
-     *
-     * Used when a process exits or is otherwise terminated.
-     *
-     * @param pid - The PID of the process that wants to release the locks.
-     */
-    releaseLocksForProcess: (pid: number) => void;
-    /**
-     * Release all locks for the given process and file descriptor.
-     *
-     * @param pid The process ID to release locks for.
-     * @param fd The file descriptor to release locks for.
-     * @param path The path to the file to release locks for. This should be the path
-     *             of the file in the underlying filesystem.
-     */
-    releaseLocksForProcessFd: (pid: number, fd: number, path: string) => void;
-};
-export type RequestedRangeLock = Readonly<{
-    /** The type of lock request */
-    type: 'shared' | 'exclusive' | 'unlocked';
-    /** The start offset of the lock range */
-    start: bigint;
-    /** The end of the lock range */
-    end: bigint;
-    /** The process ID that owns this lock */
-    pid: Pid;
-}>;
-export type WholeFileLock = Readonly<WholeFileLock_Exclusive | WholeFileLock_Shared | WholeFileLock_Unlocked>;
-export type Pid = number;
-export type Fd = number;
-export type WholeFileLock_Exclusive = {
-    type: 'exclusive';
-    pid: Pid;
-    fd: Fd;
-};
-export type WholeFileLock_Shared = {
-    type: 'shared';
-    /**
-     * NOTE: flock() locks are associated with open file descriptors and duplicated file descriptors.
-     * We do not currently recognize duplicate file descriptors.
-     */
-    pidFds: Map<Pid, Set<Fd>>;
-};
-export type WholeFileLock_Unlocked = {
-    type: 'unlocked';
-};
-export type WholeFileLockOp = {
-    pid: number;
-    fd: number;
-    type: 'shared' | 'exclusive' | 'unlock';
-};

package/lib/syscalls-for-node.d.ts

@@ -1,9 +0,0 @@
-export declare class SyscallsForNode {
-    /**
-     * Resolve a hostname to an IP address.
-     *
-     * @param hostname The hostname to resolve.
-     * @returns The IP address of the hostname as a string.
-     */
-    gethostbyname(hostname: string): Promise<string>;
-}