@gjsify/fs 0.1.13 → 0.2.0

package/lib/esm/utimes.js

@@ -0,0 +1,62 @@
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+import { normalizePath } from "./utils.js";
+function toGLibDateTime(t) {
+  const ms = t instanceof Date ? t.getTime() : typeof t === "bigint" ? Number(t) : typeof t === "string" ? Date.parse(t) : t * 1e3;
+  return GLib.DateTime.new_from_unix_utc(Math.floor(ms / 1e3));
+}
+function setTimestamps(path, atime, mtime, flags) {
+  const file = Gio.File.new_for_path(path);
+  const info = new Gio.FileInfo();
+  info.set_modification_date_time(toGLibDateTime(mtime));
+  info.set_access_date_time(toGLibDateTime(atime));
+  file.set_attributes_from_info(info, flags, null);
+}
+function utimesSync(path, atime, mtime) {
+  setTimestamps(normalizePath(path), atime, mtime, Gio.FileQueryInfoFlags.NONE);
+}
+function utimes(path, atime, mtime, callback) {
+  Promise.resolve().then(() => utimesSync(path, atime, mtime)).then(() => callback(null), callback);
+}
+async function utimesAsync(path, atime, mtime) {
+  utimesSync(path, atime, mtime);
+}
+function lutimesSync(path, atime, mtime) {
+  setTimestamps(normalizePath(path), atime, mtime, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS);
+}
+function lutimes(path, atime, mtime, callback) {
+  Promise.resolve().then(() => lutimesSync(path, atime, mtime)).then(() => callback(null), callback);
+}
+async function lutimesAsync(path, atime, mtime) {
+  lutimesSync(path, atime, mtime);
+}
+function lchownSync(path, uid, gid) {
+  GLib.spawn_command_line_sync(`chown -h ${uid}:${gid} ${normalizePath(path)}`);
+}
+function lchown(path, uid, gid, callback) {
+  Promise.resolve().then(() => lchownSync(path, uid, gid)).then(() => callback(null), callback);
+}
+async function lchownAsync(path, uid, gid) {
+  lchownSync(path, uid, gid);
+}
+function lchmodSync(_path, _mode) {
+}
+function lchmod(_path, _mode, callback) {
+  callback(null);
+}
+async function lchmodAsync(_path, _mode) {
+}
+export {
+  lchmod,
+  lchmodAsync,
+  lchmodSync,
+  lchown,
+  lchownAsync,
+  lchownSync,
+  lutimes,
+  lutimesAsync,
+  lutimesSync,
+  utimes,
+  utimesAsync,
+  utimesSync
+};

package/lib/esm/write-stream.js

@@ -1,13 +1,10 @@
 import { Writable } from "node:stream";
-import { fileURLToPath, URL } from "node:url";
 import { open, write, close } from "./callback.js";
+import { normalizePath } from "./utils.js";
 const kIsPerformingIO = /* @__PURE__ */ Symbol("kIsPerformingIO");
 const kIoDone = /* @__PURE__ */ Symbol("kIoDone");
 function toPathIfFileURL(fileURLOrPath) {
-  if (!(fileURLOrPath instanceof URL)) {
-    return fileURLOrPath;
-  }
-  return fileURLToPath(fileURLOrPath);
+  return normalizePath(fileURLOrPath);
 }
 class WriteStream extends Writable {
   /**

package/lib/types/cp.d.ts

@@ -0,0 +1,18 @@
+import type { PathLike } from 'node:fs';
+export interface CpSyncOptions {
+    dereference?: boolean;
+    errorOnExist?: boolean;
+    filter?: (src: string, dest: string) => boolean;
+    force?: boolean;
+    mode?: number;
+    preserveTimestamps?: boolean;
+    recursive?: boolean;
+    verbatimSymlinks?: boolean;
+}
+export interface CpOptions extends Omit<CpSyncOptions, 'filter'> {
+    filter?: (src: string, dest: string) => boolean | Promise<boolean>;
+}
+export declare function cpSync(src: PathLike, dest: PathLike, options?: CpSyncOptions): void;
+export declare function cp(src: PathLike, dest: PathLike, options: CpOptions | ((err: NodeJS.ErrnoException | null) => void), callback?: (err: NodeJS.ErrnoException | null) => void): void;
+declare function cpPromises(src: PathLike, dest: PathLike, opts?: CpOptions): Promise<void>;
+export { cpPromises as cpAsync };

package/lib/types/cp.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/dir.d.ts

@@ -0,0 +1,29 @@
+import Gio from '@girs/gio-2.0';
+import { Dirent } from './dirent.js';
+import type { PathLike } from 'node:fs';
+export declare class Dir {
+    readonly path: string;
+    private _enumerator;
+    private _closed;
+    constructor(path: string, enumerator: Gio.FileEnumerator);
+    private _assertOpen;
+    readSync(): Dirent | null;
+    read(): Promise<Dirent | null>;
+    read(callback: (err: NodeJS.ErrnoException | null, dirent: Dirent | null) => void): void;
+    closeSync(): void;
+    close(): Promise<void>;
+    close(callback: (err: NodeJS.ErrnoException | null) => void): void;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
+}
+export declare function opendirSync(path: PathLike): Dir;
+export declare function opendir(path: PathLike, callback: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
+export declare function opendir(path: PathLike, options: {
+    encoding?: BufferEncoding | null;
+    bufferSize?: number;
+    recursive?: boolean;
+}, callback: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
+export declare function opendirAsync(path: PathLike, _options?: {
+    encoding?: BufferEncoding | null;
+    bufferSize?: number;
+    recursive?: boolean;
+}): Promise<Dir>;

package/lib/types/dir.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/fd-ops.d.ts

@@ -0,0 +1,57 @@
+import { Stats, BigIntStats } from './stats.js';
+import type { PathLike, TimeLike, StatOptions } from 'node:fs';
+export declare function fstatSync(fd: number, options?: {
+    bigint?: false;
+}): Stats;
+export declare function fstatSync(fd: number, options: {
+    bigint: true;
+}): BigIntStats;
+export declare function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+export declare function fstat(fd: number, options: StatOptions, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+export declare function fstatAsync(fd: number, options?: StatOptions): Promise<Stats | BigIntStats>;
+export declare function ftruncateSync(fd: number, len?: number): void;
+export declare function ftruncate(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function ftruncate(fd: number, len: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function ftruncateAsync(fd: number, len?: number): Promise<void>;
+export declare function fdatasyncSync(fd: number): void;
+export declare function fdatasync(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function fdatasyncAsync(fd: number): Promise<void>;
+export declare function fsyncSync(fd: number): void;
+export declare function fsync(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function fsyncAsync(fd: number): Promise<void>;
+export declare function fchmodSync(fd: number, mode: number | string): void;
+export declare function fchmod(fd: number, mode: number | string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function fchmodAsync(fd: number, mode: number | string): Promise<void>;
+export declare function fchownSync(fd: number, uid: number, gid: number): void;
+export declare function fchown(fd: number, uid: number, gid: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function fchownAsync(fd: number, uid: number, gid: number): Promise<void>;
+export declare function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void;
+export declare function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function futimesAsync(fd: number, atime: TimeLike, mtime: TimeLike): Promise<void>;
+export declare function closeSync(fd: number): void;
+export declare function readSync(fd: number, buffer: NodeJS.ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
+export declare function readSync(fd: number, buffer: NodeJS.ArrayBufferView, options: {
+    offset?: number;
+    length?: number;
+    position?: number | null;
+}): number;
+export declare function writeSync(fd: number, buffer: NodeJS.ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
+export declare function writeSync(fd: number, string: string, position?: number | null, encoding?: BufferEncoding | null): number;
+export declare function readvSync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null): number;
+export declare function readv(fd: number, buffers: NodeJS.ArrayBufferView[], callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: NodeJS.ArrayBufferView[]) => void): void;
+export declare function readv(fd: number, buffers: NodeJS.ArrayBufferView[], position: number | null, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: NodeJS.ArrayBufferView[]) => void): void;
+export declare function readvAsync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null): Promise<{
+    bytesRead: number;
+    buffers: NodeJS.ArrayBufferView<ArrayBufferLike>[];
+}>;
+export declare function writevSync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null): number;
+export declare function writev(fd: number, buffers: NodeJS.ArrayBufferView[], callback: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void): void;
+export declare function writev(fd: number, buffers: NodeJS.ArrayBufferView[], position: number | null, callback: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: NodeJS.ArrayBufferView[]) => void): void;
+export declare function writevAsync(fd: number, buffers: NodeJS.ArrayBufferView[], position?: number | null): Promise<{
+    bytesWritten: number;
+    buffers: NodeJS.ArrayBufferView<ArrayBufferLike>[];
+}>;
+export declare function exists(path: PathLike, callback: (exists: boolean) => void): void;
+export declare function openAsBlob(path: PathLike, options?: {
+    type?: string;
+}): Promise<Blob>;

package/lib/types/fd-ops.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/file-handle.d.ts

@@ -1,28 +1,54 @@
 import { ReadStream } from "./read-stream.js";
 import { WriteStream } from "./write-stream.js";
-import { Stats } from "./stats.js";
+import { Stats, BigIntStats } from "./stats.js";
 import type { ReadableStream } from "node:stream/web";
 import { Buffer } from "node:buffer";
 import type { Abortable } from 'node:events';
 import type { FlagAndOpenMode, FileReadResult, FileReadOptions, OpenFlags } from './types/index.js';
 import type { FileHandle as IFileHandle, CreateReadStreamOptions, CreateWriteStreamOptions } from 'node:fs/promises';
-import type { ObjectEncodingOptions, Mode, OpenMode, PathLike, StatOptions, BigIntStats, WriteVResult, ReadVResult, ReadPosition } from 'node:fs';
+import type { ObjectEncodingOptions, Mode, OpenMode, PathLike, StatOptions, WriteVResult, ReadVResult, ReadPosition } from 'node:fs';
 import type { Interface as ReadlineInterface } from 'node:readline';
 export declare class FileHandle implements IFileHandle {
     readonly options: {
         path: PathLike;
-        flags?: OpenFlags;
+        flags?: OpenFlags | number;
         mode?: Mode;
     };
     /** Not part of the default implementation, used internal by gjsify */
     private _file;
+    /**
+     * Lazily-opened Gio streams for positional read() / write() so each call does
+     * not re-load the entire file via Gio.File.load_contents(). The IOStream is
+     * used when the handle was opened with write capability (r+, w, w+, a, a+) —
+     * it shares seek state between input and output so writes are visible to
+     * subsequent reads without a flush. For read-only handles we only open a
+     * FileInputStream; trying to open_readwrite on a read-only file can fall
+     * back to create_readwrite(REPLACE_DESTINATION) which would truncate it.
+     */
+    private _ioStream;
+    private _readStream;
+    private readonly _gFile;
+    private readonly _ioMode;
+    private _ioLock;
     /** Not part of the default implementation, used internal by gjsify */
     private static instances;
     constructor(options: {
         path: PathLike;
-        flags?: OpenFlags;
+        flags?: OpenFlags | number;
         mode?: Mode;
     });
+    /**
+     * Lazy-open the read-capable stream and return both the input stream and
+     * its seekable view. Both FileInputStream (read-only handle) and
+     * FileIOStream (read/write handle) implement Gio.Seekable, but we return
+     * both to avoid callers needing to know which concrete type they got.
+     */
+    private _getReadStream;
+    /** Lazy-open the write-capable stream (IOStream) for this handle. Only valid
+     *  when the handle was opened with a write-capable mode. */
+    private _getWriteStream;
+    /** Serialize an async operation on the shared FileIOStream. */
+    private _serialize;
     /**
      * The numeric file descriptor managed by the {FileHandle} object.
      * @since v10.0.0
@@ -345,6 +371,10 @@ export declare class FileHandle implements IFileHandle {
      * @return Fulfills upon success an object containing two properties:
      */
     readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<ReadVResult<TBuffers>>;
+    /** @internal */ _flushSync(): void;
+    /** @internal */ _closeSync(): void;
+    /** @internal */ _readSync(buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null): number;
+    /** @internal */ _writeSync(data: Uint8Array, position: number | null): number;
     /**
      * Closes the file handle after waiting for any pending operation on the handle to
      * complete.

package/lib/types/fs-watcher.d.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
-import type { FSWatcher as IFSWatcher } from 'node:fs';
+import type { FSWatcher as IFSWatcher, PathLike, WatchOptions } from 'node:fs';
 export declare class FSWatcher extends EventEmitter implements IFSWatcher {
-    constructor(filename: string, options: any, listener: any);
+    constructor(filename: PathLike, options: any, listener: any);
     close(): void;
     /**
      * When called, requests that the Node.js event loop not exit so long as the
@@ -15,3 +15,10 @@ export declare class FSWatcher extends EventEmitter implements IFSWatcher {
     unref(): this;
 }
 export default FSWatcher;
+type WatchEvent = {
+    eventType: string;
+    filename: string | null;
+};
+export declare function watchAsync(filename: PathLike, options?: WatchOptions & {
+    signal?: AbortSignal;
+}): AsyncIterableIterator<WatchEvent>;

package/lib/types/glob.d.ts

@@ -0,0 +1,8 @@
+export interface GlobOptions {
+    cwd?: string | URL;
+    exclude?: string | string[] | ((path: string) => boolean);
+    withFileTypes?: boolean;
+}
+export declare function globSync(pattern: string | string[], options?: GlobOptions): string[];
+export declare function glob(pattern: string | string[], options: GlobOptions | ((err: NodeJS.ErrnoException | null, matches: string[]) => void), callback?: (err: NodeJS.ErrnoException | null, matches: string[]) => void): void;
+export declare function globAsync(pattern: string | string[], options?: GlobOptions): AsyncIterableIterator<string>;

package/lib/types/glob.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/index.d.ts

@@ -4,8 +4,15 @@ import FSWatcher from './fs-watcher.js';
 import { createReadStream, ReadStream } from './read-stream.js';
 import { createWriteStream, WriteStream } from './write-stream.js';
 import * as promises from './promises.js';
+import { cpSync, cp } from './cp.js';
+import { Dir, opendir, opendirSync } from './dir.js';
+import { glob, globSync } from './glob.js';
+import { StatWatcher, watchFile, unwatchFile } from './stat-watcher.js';
+import { statfsSync, statfs } from './statfs.js';
 import { Stats, BigIntStats } from './stats.js';
 import { Dirent } from './dirent.js';
+import { utimesSync, utimes, lutimesSync, lutimes, lchownSync, lchown, lchmodSync, lchmod } from './utimes.js';
+import { fstatSync, fstat, ftruncateSync, ftruncate, fdatasyncSync, fdatasync, fsyncSync, fsync, fchmodSync, fchmod, fchownSync, fchown, futimesSync, futimes, closeSync, readSync, writeSync, readvSync, readv, writevSync, writev, exists, openAsBlob } from './fd-ops.js';
 export declare const constants: {
     F_OK: number;
     R_OK: number;
@@ -46,12 +53,14 @@ export declare const constants: {
     S_IWOTH: number;
     S_IXOTH: number;
 };
-export { FSWatcher, Stats, BigIntStats, Dirent, existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, rmdirSync, unlinkSync, mkdtempSync, rmSync, statSync, openSync, realpathSync, symlinkSync, lstatSync, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, linkSync, truncateSync, chmodSync, chownSync, watch, createReadStream, ReadStream, createWriteStream, WriteStream, promises, open, close, read, write, rm, realpath, readdir, symlink, lstat, stat, rename, copyFile, access, appendFile, readlink, truncate, chmod, chown, mkdir, rmdir, readFile, writeFile, unlink, link, };
+export { FSWatcher, StatWatcher, Stats, BigIntStats, Dirent, Dir, existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, rmdirSync, unlinkSync, mkdtempSync, rmSync, statSync, openSync, realpathSync, symlinkSync, lstatSync, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, linkSync, truncateSync, chmodSync, chownSync, cpSync, opendirSync, globSync, glob, watch, watchFile, unwatchFile, statfsSync, statfs, utimesSync, utimes, lutimesSync, lutimes, lchownSync, lchown, lchmodSync, lchmod, fstatSync, fstat, ftruncateSync, ftruncate, fdatasyncSync, fdatasync, fsyncSync, fsync, fchmodSync, fchmod, fchownSync, fchown, futimesSync, futimes, closeSync, readSync, writeSync, readvSync, readv, writevSync, writev, exists, openAsBlob, createReadStream, ReadStream, createWriteStream, WriteStream, promises, open, close, read, write, rm, realpath, readdir, symlink, lstat, stat, rename, copyFile, cp, access, appendFile, readlink, truncate, chmod, chown, mkdir, rmdir, readFile, writeFile, unlink, link, opendir, };
 declare const _default: {
     FSWatcher: typeof FSWatcher;
+    StatWatcher: typeof StatWatcher;
     Stats: typeof Stats;
     BigIntStats: typeof BigIntStats;
     Dirent: typeof Dirent;
+    Dir: typeof promises.Dir;
     constants: {
         F_OK: number;
         R_OK: number;
@@ -115,7 +124,46 @@ declare const _default: {
     truncateSync: typeof truncateSync;
     chmodSync: typeof chmodSync;
     chownSync: typeof chownSync;
+    cpSync: typeof cpSync;
+    opendirSync: typeof opendirSync;
+    globSync: typeof globSync;
+    glob: typeof glob;
     watch: typeof watch;
+    watchFile: typeof watchFile;
+    unwatchFile: typeof unwatchFile;
+    statfsSync: typeof statfsSync;
+    statfs: typeof statfs;
+    utimesSync: typeof utimesSync;
+    utimes: typeof utimes;
+    lutimesSync: typeof lutimesSync;
+    lutimes: typeof lutimes;
+    lchownSync: typeof lchownSync;
+    lchown: typeof lchown;
+    lchmodSync: typeof lchmodSync;
+    lchmod: typeof lchmod;
+    fstatSync: typeof fstatSync;
+    fstat: typeof fstat;
+    ftruncateSync: typeof ftruncateSync;
+    ftruncate: typeof ftruncate;
+    fdatasyncSync: typeof fdatasyncSync;
+    fdatasync: typeof fdatasync;
+    fsyncSync: typeof fsyncSync;
+    fsync: typeof fsync;
+    fchmodSync: typeof fchmodSync;
+    fchmod: typeof fchmod;
+    fchownSync: typeof fchownSync;
+    fchown: typeof fchown;
+    futimesSync: typeof futimesSync;
+    futimes: typeof futimes;
+    closeSync: typeof closeSync;
+    readSync: typeof readSync;
+    writeSync: typeof writeSync;
+    readvSync: typeof readvSync;
+    readv: typeof readv;
+    writevSync: typeof writevSync;
+    writev: typeof writev;
+    exists: typeof exists;
+    openAsBlob: typeof promises.openAsBlob;
     createReadStream: typeof createReadStream;
     ReadStream: typeof ReadStream;
     createWriteStream: typeof createWriteStream;
@@ -133,6 +181,7 @@ declare const _default: {
     stat: typeof stat;
     rename: typeof rename;
     copyFile: typeof copyFile;
+    cp: typeof cp;
     access: typeof access;
     appendFile: typeof appendFile;
     readlink: typeof readlink;
@@ -145,5 +194,6 @@ declare const _default: {
     writeFile: typeof writeFile;
     unlink: typeof unlink;
     link: typeof link;
+    opendir: typeof opendir;
 };
 export default _default;

package/lib/types/promises.d.ts

@@ -1,3 +1,10 @@
+import { cpAsync } from './cp.js';
+import { opendirAsync, Dir } from './dir.js';
+import { globAsync } from './glob.js';
+import { watchAsync } from './fs-watcher.js';
+import { statfsAsync } from './statfs.js';
+import { utimesAsync, lutimesAsync, lchownAsync, lchmodAsync } from './utimes.js';
+import { fstatAsync, ftruncateAsync, fdatasyncAsync, fsyncAsync, fchmodAsync, fchownAsync, futimesAsync, readvAsync, writevAsync, openAsBlob } from './fd-ops.js';
 import { FileHandle } from './file-handle.js';
 import { Dirent } from './dirent.js';
 import { Stats, BigIntStats } from './stats.js';
@@ -73,7 +80,7 @@ declare function mkdtemp(prefix: string, options: BufferEncodingOption): Promise
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
  */
 declare function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
-declare function writeFile(path: string, data: string | Uint8Array | unknown): Promise<void>;
+declare function writeFile(path: PathLike, data: string | Uint8Array | unknown): Promise<void>;
 /**
  * Removes the directory identified by `path`.
  *
@@ -85,8 +92,8 @@ declare function writeFile(path: string, data: string | Uint8Array | unknown): P
  * @return Fulfills with `undefined` upon success.
  */
 declare function rmdir(path: PathLike, _options?: RmDirOptions): Promise<void>;
-declare function unlink(path: string): Promise<void>;
-declare function open(path: PathLike, flags?: OpenFlags, mode?: Mode): Promise<FileHandle>;
+declare function unlink(path: PathLike): Promise<void>;
+declare function open(path: PathLike, flags?: OpenFlags | number, mode?: Mode): Promise<FileHandle>;
 declare function write<TBuffer extends Uint8Array>(fd: number, buffer: TBuffer, offset?: number | null, length?: number | null, position?: number | null): Promise<{
     bytesWritten: number;
     buffer: TBuffer;
@@ -129,7 +136,8 @@ declare function truncate(path: PathLike, len?: number): Promise<void>;
 declare function chmod(path: PathLike, mode: number | string): Promise<void>;
 declare function chown(path: PathLike, uid: number, gid: number): Promise<void>;
 declare function link(existingPath: PathLike, newPath: PathLike): Promise<void>;
-export { readFile, mkdir, mkdtemp, realpath, readdir, writeFile, rmdir, unlink, open, write, rm, lstat, symlink, stat, rename, copyFile, access, appendFile, readlink, truncate, chmod, chown, link, };
+export type { Dir };
+export { readFile, mkdir, mkdtemp, realpath, readdir, writeFile, rmdir, unlink, open, write, rm, lstat, symlink, stat, rename, copyFile, access, appendFile, readlink, truncate, chmod, chown, link, cpAsync as cp, opendirAsync as opendir, globAsync as glob, watchAsync as watch, statfsAsync as statfs, utimesAsync as utimes, lutimesAsync as lutimes, lchownAsync as lchown, lchmodAsync as lchmod, fstatAsync as fstat, ftruncateAsync as ftruncate, fdatasyncAsync as fdatasync, fsyncAsync as fsync, fchmodAsync as fchmod, fchownAsync as fchown, futimesAsync as futimes, readvAsync as readv, writevAsync as writev, openAsBlob, };
 declare const _default: {
     readFile: typeof readFile;
     mkdir: typeof mkdir;
@@ -154,5 +162,24 @@ declare const _default: {
     chmod: typeof chmod;
     chown: typeof chown;
     link: typeof link;
+    cp: typeof cpAsync;
+    opendir: typeof opendirAsync;
+    glob: typeof globAsync;
+    watch: typeof watchAsync;
+    statfs: typeof statfsAsync;
+    utimes: typeof utimesAsync;
+    lutimes: typeof lutimesAsync;
+    lchown: typeof lchownAsync;
+    lchmod: typeof lchmodAsync;
+    fstat: typeof fstatAsync;
+    ftruncate: typeof ftruncateAsync;
+    fdatasync: typeof fdatasyncAsync;
+    fsync: typeof fsyncAsync;
+    fchmod: typeof fchmodAsync;
+    fchown: typeof fchownAsync;
+    futimes: typeof futimesAsync;
+    readv: typeof readvAsync;
+    writev: typeof writevAsync;
+    openAsBlob: typeof openAsBlob;
 };
 export default _default;

package/lib/types/read-stream.d.ts

@@ -1,6 +1,5 @@
 import { Buffer } from "node:buffer";
 import { Readable } from "node:stream";
-import { URL } from "node:url";
 import type { CreateReadStreamOptions } from 'node:fs/promises';
 import type { PathLike, ReadStream as IReadStream } from 'node:fs';
 export declare class ReadStream extends Readable implements IReadStream {
@@ -10,12 +9,15 @@ export declare class ReadStream extends Readable implements IReadStream {
     fd: number | null;
     private _gioFile;
     private _inputStream;
+    private _cancellable;
     private _start;
     private _end;
     private _pos;
     close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
     constructor(path: PathLike, opts?: CreateReadStreamOptions);
+    _construct(callback: (err?: Error | null) => void): void;
     _read(size: number): void;
+    private _doRead;
     _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
 }
 export declare function createReadStream(path: string | URL, options?: CreateReadStreamOptions): ReadStream;

package/lib/types/stat-watcher.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'node:events';
+import type { PathLike, Stats } from 'node:fs';
+export declare class StatWatcher extends EventEmitter {
+    private _path;
+    private _interval;
+    private _timerId;
+    private _prev;
+    private _changeCount;
+    constructor(path: string, interval: number);
+    start(): void;
+    stop(): void;
+    addChangeListener(listener: (curr: Stats, prev: Stats) => void): void;
+    removeChangeListener(listener: (curr: Stats, prev: Stats) => void): void;
+    removeAllChangeListeners(): void;
+    get changeListenerCount(): number;
+}
+export declare function watchFile(filename: PathLike, options: {
+    persistent?: boolean;
+    interval?: number;
+} | ((curr: Stats, prev: Stats) => void), listener?: (curr: Stats, prev: Stats) => void): StatWatcher;
+export declare function unwatchFile(filename: PathLike, listener?: (curr: Stats, prev: Stats) => void): void;

package/lib/types/statfs.d.ts

@@ -0,0 +1,35 @@
+import type { PathLike } from 'node:fs';
+export interface StatFsResult {
+    type: number;
+    bsize: number;
+    blocks: number;
+    bfree: number;
+    bavail: number;
+    files: number;
+    ffree: number;
+}
+export interface BigIntStatFsResult {
+    type: bigint;
+    bsize: bigint;
+    blocks: bigint;
+    bfree: bigint;
+    bavail: bigint;
+    files: bigint;
+    ffree: bigint;
+}
+export declare function statfsSync(path: PathLike, options?: {
+    bigint?: false;
+}): StatFsResult;
+export declare function statfsSync(path: PathLike, options: {
+    bigint: true;
+}): BigIntStatFsResult;
+export declare function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatFsResult) => void): void;
+export declare function statfs(path: PathLike, options: {
+    bigint?: false;
+}, callback: (err: NodeJS.ErrnoException | null, stats: StatFsResult) => void): void;
+export declare function statfs(path: PathLike, options: {
+    bigint: true;
+}, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatFsResult) => void): void;
+export declare function statfsAsync(path: PathLike, options?: {
+    bigint?: boolean;
+}): Promise<StatFsResult | BigIntStatFsResult>;

package/lib/types/statfs.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/sync.d.ts

@@ -16,10 +16,7 @@ export declare function readdirSync(path: PathLike, options?: {
 }): string[] | Dirent[];
 export declare function realpathSync(path: PathLike): string;
 export declare function symlinkSync(target: PathLike, path: PathLike, _type?: 'file' | 'dir' | 'junction'): void;
-export declare function readFileSync(path: string, options?: {
-    encoding: any;
-    flag: string;
-}): string | Buffer<ArrayBuffer>;
+export declare function readFileSync(path: PathLike, options?: any): string | Buffer<ArrayBuffer>;
 /**
  * Synchronously creates a directory. Returns `undefined`, or if `recursive` is`true`, the first directory path created.
  * This is the synchronous version of {@link mkdir}.
@@ -57,7 +54,7 @@ export declare function mkdirSync(path: PathLike, options?: Mode | MakeDirectory
  */
 export declare function rmdirSync(path: PathLike, _options?: RmDirOptions): void;
 export declare function unlinkSync(path: PathLike): void;
-export declare function writeFileSync(path: string, data: string | Uint8Array): void;
+export declare function writeFileSync(path: PathLike, data: string | Uint8Array): void;
 export declare function renameSync(oldPath: PathLike, newPath: PathLike): void;
 export declare function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
 export declare function accessSync(path: PathLike, mode?: number): void;
@@ -73,12 +70,12 @@ export declare function linkSync(existingPath: PathLike, newPath: PathLike): voi
 export declare function truncateSync(path: PathLike, len?: number): void;
 export declare function chmodSync(path: PathLike, mode: Mode): void;
 export declare function chownSync(path: PathLike, uid: number, gid: number): void;
-export declare function watch(filename: string, options: {
+export declare function watch(filename: PathLike, options: {
     persistent?: boolean;
     recursive?: boolean;
     encoding?: string;
 } | undefined, listener: ((eventType: string, filename: string | null) => void) | undefined): FSWatcher;
-export declare function openSync(path: PathLike, flags?: OpenFlags, mode?: Mode): FileHandle;
+export declare function openSync(path: PathLike, flags?: OpenFlags | number, mode?: Mode): FileHandle;
 /**
  * Returns the created directory path.
  *

package/lib/types/utils.d.ts

@@ -1,2 +1,4 @@
+import type { PathLike } from 'node:fs';
+export declare function normalizePath(path: PathLike): string;
 export declare function randomName(): string;
 export declare function tempDirPath(prefix: string): string;

package/lib/types/utimes.d.ts

@@ -0,0 +1,13 @@
+import type { PathLike, TimeLike } from 'node:fs';
+export declare function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+export declare function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function utimesAsync(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
+export declare function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+export declare function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function lutimesAsync(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
+export declare function lchownSync(path: PathLike, uid: number, gid: number): void;
+export declare function lchown(path: PathLike, uid: number, gid: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function lchownAsync(path: PathLike, uid: number, gid: number): Promise<void>;
+export declare function lchmodSync(_path: PathLike, _mode: number): void;
+export declare function lchmod(_path: PathLike, _mode: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+export declare function lchmodAsync(_path: PathLike, _mode: number): Promise<void>;

package/lib/types/utimes.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/watch.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/watchfile.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/write-stream.d.ts

@@ -1,10 +1,9 @@
 import { Writable } from "node:stream";
-import { URL } from "node:url";
 import type { OpenFlags } from './types/index.js';
 import type { PathLike, WriteStream as IWriteStream } from 'node:fs';
 import type { CreateWriteStreamOptions } from 'node:fs/promises';
 declare const kIsPerformingIO: unique symbol;
-export declare function toPathIfFileURL(fileURLOrPath: string | Buffer | URL): string | Buffer;
+export declare function toPathIfFileURL(fileURLOrPath: string | Buffer | URL): string;
 export declare class WriteStream extends Writable implements IWriteStream {
     /**
      * Closes `writeStream`. Optionally accepts a