@gjsify/fs 0.0.4 → 0.1.1

package/src/callback.ts

@@ -1,14 +1,104 @@
+// Reference: Node.js lib/fs.js (callback API)
+// Reimplemented for GJS using Gio.File async operations
+
+import GLib from '@girs/glib-2.0';
+import Gio from '@girs/gio-2.0';
 import { open as openP, rm as rmP } from './promises.js'
-import { warnNotImplemented } from '@gjsify/utils';
-import { PathLike, OpenMode, Mode, ReadPosition, ReadAsyncOptions, NoParamCallback, RmOptions } from 'fs';
+import { PathLike, OpenMode, Mode, ReadPosition, ReadAsyncOptions, NoParamCallback, RmOptions, RmDirOptions, MakeDirectoryOptions } from 'node:fs';
 import { FileHandle } from './file-handle.js';
-import { Buffer } from 'buffer';
+import { Buffer } from 'node:buffer';
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from './stats.js';
+import { createNodeError } from './errors.js';
+import { realpathSync, readdirSync, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, mkdirSync, rmdirSync, readFileSync, writeFileSync } from './sync.js';
+// encoding helpers available if needed in future
+
+import type { OpenFlags } from './types/index.js';
+
+// --- helpers ---
+
+function parseOptsCb(optionsOrCallback: unknown, maybeCallback?: Function): { options: Record<string, unknown>; callback: Function } {
+  return typeof optionsOrCallback === 'function'
+    ? { options: {}, callback: optionsOrCallback }
+    : { options: (optionsOrCallback ?? {}) as Record<string, unknown>, callback: maybeCallback! };
+}
+
+function statImpl(path: PathLike, flags: Gio.FileQueryInfoFlags, syscall: string, options: Record<string, unknown>, callback: Function): void {
+  const file = Gio.File.new_for_path(path.toString());
+  file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s: Gio.File, res: Gio.AsyncResult) => {
+    try {
+      const info = file.query_info_finish(res);
+      callback(null, options?.bigint ? new BigIntStats(info, path) : new Stats(info, path));
+    } catch (err: unknown) {
+      callback(createNodeError(err, syscall, path));
+    }
+  });
+}
+
+// --- stat / lstat ---
+
+export function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+export function stat(path: PathLike, options: { bigint?: boolean }, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+export function stat(path: PathLike, optionsOrCallback: { bigint?: boolean } | ((err: NodeJS.ErrnoException | null, stats: Stats) => void), maybeCallback?: Function): void {
+  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  statImpl(path, Gio.FileQueryInfoFlags.NONE, 'stat', options, callback);
+}
+
+export function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+export function lstat(path: PathLike, options: { bigint?: boolean }, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+export function lstat(path: PathLike, optionsOrCallback: { bigint?: boolean } | ((err: NodeJS.ErrnoException | null, stats: Stats) => void), maybeCallback?: Function): void {
+  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  statImpl(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, 'lstat', options, callback);
+}
+
+// --- readdir ---
+
+export function readdir(path: PathLike, callback: (err: NodeJS.ErrnoException | null, files: string[]) => void): void;
+export function readdir(path: PathLike, options: { withFileTypes?: boolean; encoding?: string; recursive?: boolean }, callback: (err: NodeJS.ErrnoException | null, files: string[] | unknown[]) => void): void;
+export function readdir(path: PathLike, optionsOrCallback: { withFileTypes?: boolean; encoding?: string; recursive?: boolean } | ((err: NodeJS.ErrnoException | null, files: string[]) => void), maybeCallback?: Function): void {
+  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  Promise.resolve().then(() => {
+    try {
+      callback(null, readdirSync(path, options as { withFileTypes?: boolean; encoding?: string; recursive?: boolean }));
+    } catch (err: unknown) {
+      callback(createNodeError(err, 'readdir', path));
+    }
+  });
+}
+
+// --- realpath ---
+
+export function realpath(path: PathLike, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
+export function realpath(path: PathLike, options: { encoding?: BufferEncoding }, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
+export function realpath(path: PathLike, optionsOrCallback: { encoding?: BufferEncoding } | ((err: NodeJS.ErrnoException | null, resolvedPath: string) => void), maybeCallback?: Function): void {
+  const { callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  Promise.resolve().then(() => {
+    try {
+      callback(null, realpathSync(path));
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
 
-export { realpath } from '@gjsify/deno_std/node/_fs/_fs_realpath';
-export { readdir } from '@gjsify/deno_std/node/_fs/_fs_readdir';
-export { symlink } from '@gjsify/deno_std/node/_fs/_fs_symlink';
-export { lstat } from '@gjsify/deno_std/node/_fs/_fs_lstat';
-export { stat } from '@gjsify/deno_std/node/_fs/_fs_stat';
+// --- symlink ---
+
+export function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
+export function symlink(target: PathLike, path: PathLike, type: string | null, callback: NoParamCallback): void;
+export function symlink(target: PathLike, path: PathLike, typeOrCallback: string | null | NoParamCallback, maybeCallback?: NoParamCallback): void {
+  const callback: NoParamCallback = typeof typeOrCallback === 'function' ? typeOrCallback : maybeCallback!;
+  if (typeof callback !== 'function') {
+    throw new TypeError('Callback must be a function. Received ' + typeof callback);
+  }
+  const file = Gio.File.new_for_path(path.toString());
+  file.make_symbolic_link_async(target.toString(), GLib.PRIORITY_DEFAULT, null, (_s: Gio.File, res: Gio.AsyncResult) => {
+    try {
+      file.make_symbolic_link_finish(res);
+      callback(null);
+    } catch (err: unknown) {
+      callback(createNodeError(err, 'symlink', target, path));
+    }
+  });
+}
 
 type OpenCallback = (err: NodeJS.ErrnoException | null, fd: number) => void;
 
@@ -47,29 +137,29 @@ export function open(path: PathLike, flags: OpenMode | undefined, callback: Open
  */
 export function open(path: PathLike, callback: OpenCallback): void;
 
-export function open(path: PathLike, ...args: any[]): void {
-    let flags: number | OpenMode | undefined;
+export function open(path: PathLike, ...args: (OpenMode | Mode | OpenCallback | undefined | null)[]): void {
+    let flags: OpenMode | undefined;
     let mode: Mode | undefined | null;
     let callback: OpenCallback
 
     switch (args.length) {
         case 1:
-            callback = args[0]
+            callback = args[0] as OpenCallback
             break;
         case 2:
-            flags = args[0]
-            callback = args[1]
+            flags = args[0] as OpenMode | undefined
+            callback = args[1] as OpenCallback
             break;
         case 3:
-            flags = args[0]
-            mode = args[1]
-            callback = args[2]
+            flags = args[0] as OpenMode | undefined
+            mode = args[1] as Mode | undefined | null
+            callback = args[2] as OpenCallback
             break;
         default:
             break;
     }
 
-    openP(path, flags as any, mode)
+    openP(path, flags as OpenFlags | undefined, mode)
     .then((fileHandle) => {
         callback(null, fileHandle.fd);
     })
@@ -167,14 +257,16 @@ export function write(fd: number, string: string, position: number | undefined |
  */
 export function write(fd: number, string: string, callback: WriteStrCallback): void;
 
-export function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, data: string | TBuffer, ...args: any[]): void {
+export function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, data: string | TBuffer, ...args: (number | string | BufferEncoding | WriteStrCallback | WriteBufCallback | undefined | null)[]): void {
 
     const fileHandle = FileHandle.getInstance(fd);
-    
+
     if (typeof data === 'string') {
-        const callback: WriteStrCallback = args[args.length -1];
+        const callback = args.pop() as WriteStrCallback;
+        const position = args[0] as number | undefined | null;
+        const encoding = args[1] as BufferEncoding | undefined | null;
 
-        fileHandle.write(data, ...args.pop())
+        fileHandle.write(data, position, encoding)
         .then((res) => {
             callback(null, res.bytesWritten, res.buffer);
         })
@@ -185,10 +277,10 @@ export function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, data:
         return;
     }
 
-    const callback: WriteBufCallback = args[args.length -1];
-    const offset: number | undefined = args[0];
-    const length: number | undefined = args[1];
-    const position: number | undefined = args[2];
+    const callback = args[args.length -1] as WriteBufCallback;
+    const offset = args[0] as number | undefined;
+    const length = args[1] as number | undefined;
+    const position = args[2] as number | undefined;
 
     fileHandle.write(data, offset, length, position)
     .then((res) => {
@@ -281,33 +373,32 @@ export function read<TBuffer extends NodeJS.ArrayBufferView>(
 ): void;
 export function read(fd: number, callback: ReadCallback): void;
 
-export function read(fd: number, ...args: any[]): void {
+export function read(fd: number, ...args: unknown[]): void {
 
     const fileHandle = FileHandle.getInstance(fd);
 
-    const callback: ReadCallback = args[args.length -1];
-    const err = new Error(warnNotImplemented('fs.read'));
-    callback(err, 0, Buffer.from(''));
+    const callback: ReadCallback = args[args.length -1] as ReadCallback;
 
     let buffer: NodeJS.ArrayBufferView | undefined;
     let offset: number | null | undefined;
     let length: number | null | undefined;
     let position: ReadPosition | null | undefined;
 
-    if (typeof args[0] === 'object') {
-        const options: ReadAsyncOptions<any> = args[0];
+    if (args.length <= 1) {
+        // read(fd, callback) — use defaults
+    } else if (typeof args[0] === 'object' && !ArrayBuffer.isView(args[0])) {
+        const options = args[0] as ReadAsyncOptions<NodeJS.ArrayBufferView>;
         buffer = options.buffer;
         offset = options.offset;
         length = options.length;
         position = options.position;
     } else {
-        buffer = args[0];
-        offset = args[1];
-        length = args[2];
-        position = args[3];
+        buffer = args[0] as NodeJS.ArrayBufferView | undefined;
+        offset = args[1] as number | null | undefined;
+        length = args[2] as number | null | undefined;
+        position = args[3] as ReadPosition | null | undefined;
     }
 
-
     fileHandle.read(buffer, offset, length, position)
     .then((res) => {
         callback(null, res.bytesRead, res.buffer);
@@ -343,13 +434,13 @@ export function close(fd: number, callback?: NoParamCallback): void {
 export function rm(path: PathLike, callback: NoParamCallback): void;
 export function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
 
-export function rm(path: PathLike, ...args: any[]): void {
+export function rm(path: PathLike, ...args: (RmOptions | NoParamCallback)[]): void {
 
     let options: RmOptions = {};
-    let callback: NoParamCallback = args[args.length -1];
+    let callback: NoParamCallback = args[args.length -1] as NoParamCallback;
 
     if (args.length >= 2) {
-        options = args[0];
+        options = args[0] as RmOptions;
     }
 
     rmP(path, options)
@@ -359,4 +450,226 @@ export function rm(path: PathLike, ...args: any[]): void {
     .catch((err) => {
         callback(err);
     });
+}
+
+// --- rename ---
+
+export function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void {
+  Promise.resolve().then(() => {
+    try {
+      renameSync(oldPath, newPath);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- copyFile ---
+
+export function copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
+export function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
+export function copyFile(src: PathLike, dest: PathLike, modeOrCb: number | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const mode = typeof modeOrCb === 'function' ? 0 : modeOrCb;
+  const callback = typeof modeOrCb === 'function' ? modeOrCb : maybeCb!;
+  Promise.resolve().then(() => {
+    try {
+      copyFileSync(src, dest, mode);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- access ---
+
+export function access(path: PathLike, callback: NoParamCallback): void;
+export function access(path: PathLike, mode: number, callback: NoParamCallback): void;
+export function access(path: PathLike, modeOrCb: number | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const mode = typeof modeOrCb === 'function' ? undefined : modeOrCb;
+  const callback = typeof modeOrCb === 'function' ? modeOrCb : maybeCb!;
+  Promise.resolve().then(() => {
+    try {
+      accessSync(path, mode);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- appendFile ---
+
+export function appendFile(path: PathLike, data: string | Uint8Array, callback: NoParamCallback): void;
+export function appendFile(path: PathLike, data: string | Uint8Array, options: { encoding?: string; mode?: number; flag?: string } | string, callback: NoParamCallback): void;
+export function appendFile(path: PathLike, data: string | Uint8Array, optsOrCb: { encoding?: string; mode?: number; flag?: string } | string | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const callback = typeof optsOrCb === 'function' ? optsOrCb : maybeCb!;
+  const options = typeof optsOrCb === 'function' ? undefined : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      appendFileSync(path, data, options);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- readlink ---
+
+export function readlink(path: PathLike, callback: (err: NodeJS.ErrnoException | null, linkString: string) => void): void;
+export function readlink(path: PathLike, options: { encoding?: string } | string, callback: (err: NodeJS.ErrnoException | null, linkString: string | Buffer) => void): void;
+export function readlink(path: PathLike, optsOrCb: { encoding?: string } | string | ((err: NodeJS.ErrnoException | null, linkString: string | Buffer) => void), maybeCb?: (err: NodeJS.ErrnoException | null, linkString: string | Buffer) => void): void {
+  const callback = typeof optsOrCb === 'function' ? optsOrCb : maybeCb!;
+  const options = typeof optsOrCb === 'function' ? undefined : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      callback(null, readlinkSync(path, options));
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException, '');
+    }
+  });
+}
+
+// --- truncate ---
+
+export function truncate(path: PathLike, callback: NoParamCallback): void;
+export function truncate(path: PathLike, len: number, callback: NoParamCallback): void;
+export function truncate(path: PathLike, lenOrCb: number | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const len = typeof lenOrCb === 'function' ? 0 : lenOrCb;
+  const callback = typeof lenOrCb === 'function' ? lenOrCb : maybeCb!;
+  Promise.resolve().then(() => {
+    try {
+      truncateSync(path, len);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- chmod ---
+
+export function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void {
+  Promise.resolve().then(() => {
+    try {
+      chmodSync(path, mode);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- chown ---
+
+export function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void {
+  Promise.resolve().then(() => {
+    try {
+      chownSync(path, uid, gid);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- mkdir (callback) ---
+
+export function mkdir(path: PathLike, callback: NoParamCallback): void;
+export function mkdir(path: PathLike, options: MakeDirectoryOptions | Mode, callback: NoParamCallback): void;
+export function mkdir(path: PathLike, optsOrCb: MakeDirectoryOptions | Mode | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const callback = typeof optsOrCb === 'function' ? optsOrCb : maybeCb!;
+  const options = typeof optsOrCb === 'function' ? undefined : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      mkdirSync(path, options as MakeDirectoryOptions | Mode | undefined);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- rmdir (callback) ---
+
+export function rmdir(path: PathLike, callback: NoParamCallback): void;
+export function rmdir(path: PathLike, options: RmDirOptions, callback: NoParamCallback): void;
+export function rmdir(path: PathLike, optsOrCb: RmDirOptions | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const callback = typeof optsOrCb === 'function' ? optsOrCb : maybeCb!;
+  const options = typeof optsOrCb === 'function' ? undefined : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      rmdirSync(path, options);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- readFile (callback) ---
+
+export function readFile(path: PathLike, callback: (err: NodeJS.ErrnoException | null, data: Buffer) => void): void;
+export function readFile(path: PathLike, options: { encoding?: string; flag?: string } | string, callback: (err: NodeJS.ErrnoException | null, data: string | Buffer) => void): void;
+export function readFile(path: PathLike, optsOrCb: { encoding?: string; flag?: string } | string | ((err: NodeJS.ErrnoException | null, data: Buffer) => void), maybeCb?: (err: NodeJS.ErrnoException | null, data: string | Buffer | null) => void): void {
+  const callback = typeof optsOrCb === 'function' ? optsOrCb : maybeCb!;
+  const options = typeof optsOrCb === 'function' ? undefined : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      const readOpts = typeof options === 'string' ? { encoding: options as string | null, flag: 'r' } : { encoding: (options?.encoding ?? null) as string | null, flag: options?.flag ?? 'r' };
+      callback(null, readFileSync(path.toString(), readOpts) as unknown as Buffer);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException, null as unknown as Buffer);
+    }
+  });
+}
+
+// --- writeFile (callback) ---
+
+export function writeFile(path: PathLike, data: string | Uint8Array, callback: NoParamCallback): void;
+export function writeFile(path: PathLike, data: string | Uint8Array, options: { encoding?: string; mode?: number; flag?: string } | string, callback: NoParamCallback): void;
+export function writeFile(path: PathLike, data: string | Uint8Array, optsOrCb: { encoding?: string; mode?: number; flag?: string } | string | NoParamCallback, maybeCb?: NoParamCallback): void {
+  const callback = typeof optsOrCb === 'function' ? optsOrCb : maybeCb!;
+  Promise.resolve().then(() => {
+    try {
+      writeFileSync(path.toString(), data);
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- link (callback) ---
+
+export function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void {
+  Promise.resolve().then(() => {
+    try {
+      const result = GLib.spawn_command_line_sync(`ln ${existingPath.toString()} ${newPath.toString()}`);
+      if (!result[0]) {
+        throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingPath}' -> '${newPath}'`), {
+          code: 'EPERM', errno: -1, syscall: 'link',
+          path: existingPath.toString(), dest: newPath.toString()
+        });
+      }
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
+}
+
+// --- unlink (callback) ---
+
+export function unlink(path: PathLike, callback: NoParamCallback): void {
+  Promise.resolve().then(() => {
+    try {
+      GLib.unlink(path.toString());
+      callback(null);
+    } catch (err: unknown) {
+      callback(err as NodeJS.ErrnoException);
+    }
+  });
 }

package/src/dirent.ts

@@ -1,7 +1,20 @@
+// Reference: Node.js lib/internal/fs/utils.js (Dirent class)
+// Reimplemented for GJS using Gio.FileInfo
+
 import Gio from '@girs/gio-2.0';
-import { basename } from 'path';
+import { basename, dirname } from 'node:path';
+
+import type { Dirent as OriginalDirent } from 'node:fs'; // Types from @types/node
 
-import type { Dirent as OriginalDirent } from 'fs'; // Types from @types/node
+// POSIX file type constants from stat mode bits (S_IFMT mask = 0o170000)
+const S_IFMT   = 0o170000;
+const S_IFSOCK = 0o140000;
+const S_IFLNK  = 0o120000;
+const S_IFREG  = 0o100000;
+const S_IFBLK  = 0o060000;
+const S_IFDIR  = 0o040000;
+const S_IFCHR  = 0o020000;
+const S_IFIFO  = 0o010000;
 
 /**
  * A representation of a directory entry, which can be a file or a subdirectory
@@ -21,6 +34,12 @@ export class Dirent implements OriginalDirent {
      */
     name: string;
 
+    /**
+     * The path to the parent directory of the file this `fs.Dirent` object refers to.
+     * @since v20.12.0, v18.20.0
+     */
+    parentPath: string;
+
     private _isFile = false;
     private _isDirectory = false;
     private _isBlockDevice = false;
@@ -33,11 +52,12 @@ export class Dirent implements OriginalDirent {
     protected _file: Gio.File;
 
     /** This is not part of node.fs and is used internal by gjsify */
-    constructor(path: string, filename?: string) {
+    constructor(path: string, filename?: string, fileType?: Gio.FileType) {
         if (!filename) filename = basename(path);
         this.name = filename;
+        this.parentPath = dirname(path);
         this._file = Gio.File.new_for_path(path);
-        const type = this._file.query_file_type(Gio.FileQueryInfoFlags.NONE, null);
+        const type = fileType ?? this._file.query_file_type(Gio.FileQueryInfoFlags.NONE, null);
 
         switch (type) {
             case Gio.FileType.DIRECTORY:
@@ -54,15 +74,43 @@ export class Dirent implements OriginalDirent {
                 break;
             case Gio.FileType.SPECIAL:
                 // File is a "special" file, such as a socket, fifo, block device, or character device.
-                this._isBlockDevice = Gio.unix_is_system_device_path(path);
-                // TODO: this._isCharacterDevice = 
-                // TODO: this._isSocket = 
-                // TODO: this._isFifo = 
+                // Use unix::mode from Gio.FileInfo to distinguish the exact type via POSIX S_IFMT bits.
+                this._classifySpecialFile(path);
                 break;
         }
 
     }
 
+    /**
+     * Classify a SPECIAL file type using the unix::mode attribute from Gio.FileInfo.
+     * Falls back to marking nothing if the mode attribute is unavailable.
+     */
+    private _classifySpecialFile(path: string): void {
+        try {
+            const file = Gio.File.new_for_path(path);
+            const info = file.query_info('unix::mode', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+            const mode = info.get_attribute_uint32('unix::mode');
+            if (mode === 0) return;
+            const fmt = mode & S_IFMT;
+            switch (fmt) {
+                case S_IFBLK:
+                    this._isBlockDevice = true;
+                    break;
+                case S_IFCHR:
+                    this._isCharacterDevice = true;
+                    break;
+                case S_IFSOCK:
+                    this._isSocket = true;
+                    break;
+                case S_IFIFO:
+                    this._isFIFO = true;
+                    break;
+            }
+        } catch {
+            // If we can't query the mode (e.g. permission denied), leave all flags as false
+        }
+    }
+
     /**
      * Returns `true` if the `fs.Dirent` object describes a regular file.
      * @since v10.10.0

package/src/encoding.ts

@@ -1,7 +1,12 @@
-import { Buffer } from 'buffer';
+// SPDX-License-Identifier: MIT
+// Adapted from Deno (refs/deno/ext/node/polyfills/_fs/_fs_mkdtemp.ts)
+// Copyright (c) 2018-2026 the Deno authors. MIT license.
+// Modifications: Extracted encoding helpers, adapted for GJS
+
+import { Buffer } from 'node:buffer';
 
 import type { ReadOptions } from './types/index.js';
-import type { ObjectEncodingOptions, BufferEncodingOption } from 'fs'; // Types from @types/node
+import type { ObjectEncodingOptions, BufferEncodingOption } from 'node:fs'; // Types from @types/node
 
 export function getEncodingFromOptions(options: ReadOptions | ObjectEncodingOptions | BufferEncodingOption= { encoding: null, flag: 'r' }, defaultEncoding: null | BufferEncoding | "buffer" = 'utf8'): BufferEncoding | 'buffer' {
   if (options === null) {