@gjsify/fs 0.1.15 → 0.3.0

package/src/statfs.ts

@@ -0,0 +1,92 @@
+// Reference: Node.js lib/fs.js (fs.statfs / fs.promises.statfs)
+// Reimplemented for GJS using Gio.File.query_filesystem_info
+
+import Gio from '@girs/gio-2.0';
+import GLib from '@girs/glib-2.0';
+import { normalizePath } from './utils.js';
+
+import type { PathLike } from 'node:fs';
+
+const FS_INFO_ATTRS = [
+  'filesystem::size',
+  'filesystem::free',
+].join(',');
+
+// Block size used to derive block counts from byte counts.
+// Gio does not expose the real fs block size; 4096 is a safe default.
+const BSIZE = 4096;
+
+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;
+}
+
+function buildStatFs(info: Gio.FileInfo): StatFsResult {
+  const totalBytes = Number(info.get_attribute_uint64('filesystem::size') ?? 0);
+  const freeBytes  = Number(info.get_attribute_uint64('filesystem::free') ?? 0);
+  const blocks = Math.floor(totalBytes / BSIZE);
+  const bfree  = Math.floor(freeBytes  / BSIZE);
+  return { type: 0, bsize: BSIZE, blocks, bfree, bavail: bfree, files: 0, ffree: 0 };
+}
+
+function buildBigIntStatFs(info: Gio.FileInfo): BigIntStatFsResult {
+  const totalBytes = BigInt(info.get_attribute_uint64('filesystem::size') ?? 0);
+  const freeBytes  = BigInt(info.get_attribute_uint64('filesystem::free') ?? 0);
+  const bsize = BigInt(BSIZE);
+  const blocks = totalBytes / bsize;
+  const bfree  = freeBytes  / bsize;
+  return { type: 0n, bsize, blocks, bfree, bavail: bfree, files: 0n, ffree: 0n };
+}
+
+export function statfsSync(path: PathLike, options?: { bigint?: false }): StatFsResult;
+export function statfsSync(path: PathLike, options: { bigint: true }): BigIntStatFsResult;
+export function statfsSync(path: PathLike, options?: { bigint?: boolean }): StatFsResult | BigIntStatFsResult {
+  const file = Gio.File.new_for_path(normalizePath(path));
+  const info = file.query_filesystem_info(FS_INFO_ATTRS, null);
+  return options?.bigint === true ? buildBigIntStatFs(info) : buildStatFs(info);
+}
+
+function queryFsInfoAsync(path: PathLike, useBigInt: boolean): Promise<StatFsResult | BigIntStatFsResult> {
+  return new Promise((resolve, reject) => {
+    const file = Gio.File.new_for_path(normalizePath(path));
+    file.query_filesystem_info_async(FS_INFO_ATTRS, GLib.PRIORITY_DEFAULT, null, (_s: unknown, res: Gio.AsyncResult) => {
+      try {
+        const info = file.query_filesystem_info_finish(res);
+        resolve(useBigInt ? buildBigIntStatFs(info) : buildStatFs(info));
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+
+export function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatFsResult) => void): void;
+export function statfs(path: PathLike, options: { bigint?: false }, callback: (err: NodeJS.ErrnoException | null, stats: StatFsResult) => void): void;
+export function statfs(path: PathLike, options: { bigint: true }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatFsResult) => void): void;
+export function statfs(path: PathLike, optionsOrCb: any, callback?: any): void {
+  if (typeof optionsOrCb === 'function') {
+    callback = optionsOrCb;
+    optionsOrCb = {};
+  }
+  const useBigInt = optionsOrCb?.bigint === true;
+  queryFsInfoAsync(path, useBigInt).then(result => callback(null, result), err => callback(err, null));
+}
+
+export async function statfsAsync(path: PathLike, options?: { bigint?: boolean }): Promise<StatFsResult | BigIntStatFsResult> {
+  return queryFsInfoAsync(path, options?.bigint === true);
+}

package/src/streams.spec.ts

@@ -159,6 +159,64 @@ export default async () => {
         cleanup();
       }
     });
+
+    // Regression: ReadStream uses _construct() for async file opening.
+    // Verifies that 'open' and 'ready' fire and that pending starts as true.
+    await it('should emit open and ready events before data, pending starts true', async () => {
+      setup();
+      try {
+        const filePath = join(tmpDir, 'open-ready.txt');
+        writeFileSync(filePath, 'hello');
+        const stream = createReadStream(filePath);
+        expect(stream.pending).toBeTruthy();
+        const events: string[] = [];
+        let openFd: number | undefined;
+        await new Promise<void>((resolve, reject) => {
+          stream.on('open', (fd: number) => { openFd = fd; events.push('open'); });
+          stream.on('ready', () => events.push('ready'));
+          stream.on('data', () => { if (!events.includes('data')) events.push('data'); });
+          stream.on('end', () => resolve());
+          stream.on('error', reject);
+          stream.resume();
+        });
+        expect(openFd).toBeDefined();
+        // 'open' and 'ready' must have fired (file was opened)
+        expect(events).toContain('open');
+        expect(events).toContain('ready');
+        // 'open' must fire before any data event
+        const openIdx = events.indexOf('open');
+        const dataIdx = events.indexOf('data');
+        if (dataIdx !== -1) expect(openIdx).toBeLessThan(dataIdx);
+      } finally {
+        cleanup();
+      }
+    });
+
+    // Regression: piping a ReadStream before the file is open (while pending=true)
+    // must still deliver all data. Previously _pendingReadSize approach hung under
+    // backpressure on GJS 1.88; _construct() fixes this properly.
+    await it('should pipe correctly when pipe() is called before file opens', async () => {
+      setup();
+      try {
+        const srcPath = join(tmpDir, 'pre-pipe-src.txt');
+        const dstPath = join(tmpDir, 'pre-pipe-dst.txt');
+        const size = 3 * 64 * 1024; // 3 × 64KB — forces multiple read chunks + backpressure
+        writeFileSync(srcPath, 'X'.repeat(size));
+        await new Promise<void>((resolve, reject) => {
+          const src = createReadStream(srcPath);
+          const dst = createWriteStream(dstPath);
+          // pipe() is called immediately — src is still pending (file not open yet)
+          expect(src.pending).toBeTruthy();
+          src.on('error', reject);
+          dst.on('error', reject);
+          dst.on('finish', resolve);
+          src.pipe(dst);
+        });
+        expect(readFileSync(dstPath, 'utf8').length).toBe(size);
+      } finally {
+        cleanup();
+      }
+    });
   });
 
   // ---- createWriteStream ----

package/src/sync.ts

@@ -13,7 +13,7 @@ import { FileHandle } from './file-handle.js';
 import { Dirent } from './dirent.js';
 import { Stats, BigIntStats, STAT_ATTRIBUTES } from './stats.js';
 import { createNodeError, isNotFoundError } from './errors.js';
-import { tempDirPath } from './utils.js';
+import { tempDirPath, normalizePath } from './utils.js';
 
 import type { OpenFlags, EncodingOption } from './types/index.js';
 import type {
@@ -31,24 +31,26 @@ export { existsSync }
 // --- stat / lstat ---
 
 export function statSync(path: PathLike, options?: StatSyncOptions): Stats | BigIntStats | undefined {
+  const pathStr = normalizePath(path);
   try {
-    const file = Gio.File.new_for_path(path.toString());
+    const file = Gio.File.new_for_path(pathStr);
     const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NONE, null);
-    return options?.bigint ? new BigIntStats(info, path) : new Stats(info, path);
+    return options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
   } catch (err: unknown) {
     if (options?.throwIfNoEntry === false && isNotFoundError(err)) return undefined;
-    throw createNodeError(err, 'stat', path);
+    throw createNodeError(err, 'stat', pathStr);
   }
 }
 
 export function lstatSync(path: PathLike, options?: StatSyncOptions): Stats | BigIntStats | undefined {
+  const pathStr = normalizePath(path);
   try {
-    const file = Gio.File.new_for_path(path.toString());
+    const file = Gio.File.new_for_path(pathStr);
     const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-    return options?.bigint ? new BigIntStats(info, path) : new Stats(info, path);
+    return options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr);
   } catch (err: unknown) {
     if (options?.throwIfNoEntry === false && isNotFoundError(err)) return undefined;
-    throw createNodeError(err, 'lstat', path);
+    throw createNodeError(err, 'lstat', pathStr);
   }
 }
 
@@ -58,7 +60,7 @@ export function readdirSync(
   path: PathLike,
   options?: { withFileTypes?: boolean; encoding?: string; recursive?: boolean }
 ): string[] | Dirent[] {
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   const file = Gio.File.new_for_path(pathStr);
   const enumerator = file.enumerate_children(
     'standard::name,standard::type',
@@ -101,7 +103,8 @@ export function readdirSync(
 const MAX_SYMLINK_DEPTH = 40; // matches Linux MAXSYMLINKS
 
 export function realpathSync(path: PathLike): string {
-  let current = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  let current = Gio.File.new_for_path(pathStr);
   let depth = 0;
 
   while (true) {
@@ -120,7 +123,7 @@ export function realpathSync(path: PathLike): string {
     current = parent ? parent.resolve_relative_path(target) : Gio.File.new_for_path(target);
 
     if (++depth > MAX_SYMLINK_DEPTH) {
-      throw new Error(`ELOOP: too many levels of symbolic links, realpath '${path}'`);
+      throw new Error(`ELOOP: too many levels of symbolic links, realpath '${pathStr}'`);
     }
   }
 }
@@ -129,24 +132,27 @@ export function realpathSync(path: PathLike): string {
 // --- symlink ---
 
 export function symlinkSync(target: PathLike, path: PathLike, _type?: 'file' | 'dir' | 'junction'): void {
-  const file = Gio.File.new_for_path(path.toString());
-  file.make_symbolic_link(target.toString(), null);
+  const pathStr = normalizePath(path);
+  const targetStr = normalizePath(target);
+  const file = Gio.File.new_for_path(pathStr);
+  file.make_symbolic_link(targetStr, null);
 }
 
-export function readFileSync(path: string, options = { encoding: null, flag: 'r' }) {
-  const file = Gio.File.new_for_path(path);
+export function readFileSync(path: PathLike, options: any = { encoding: null, flag: 'r' }) {
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
 
   try {
     const [ok, data] = file.load_contents(null);
 
     if (!ok) {
-      throw createNodeError(new Error('failed to read file'), 'read', path);
+      throw createNodeError(new Error('failed to read file'), 'read', pathStr);
     }
 
     return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
   } catch (err: unknown) {
     if ((err as { code?: unknown }).code && typeof (err as { code?: unknown }).code === 'string') throw err; // Already a Node error
-    throw createNodeError(err, 'read', path);
+    throw createNodeError(err, 'read', pathStr);
   }
 }
 
@@ -203,9 +209,7 @@ export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions
     mode = options || 0o777;
   }
 
-  if (typeof path !== 'string') {
-    path = path.toString();
-  }
+  path = normalizePath(path);
 
   if(typeof mode === 'string') {
     throw new TypeError("mode as string is currently not supported!");
@@ -275,57 +279,63 @@ function mkdirSyncRecursive(pathStr: string, mode: number): string | undefined {
  * @since v0.1.21
  */
 export function rmdirSync(path: PathLike, _options?: RmDirOptions): void {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   try {
     // Check if it's a directory
     const info = file.query_info('standard::type', Gio.FileQueryInfoFlags.NONE, null);
     if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
       const err = Object.assign(new Error(), { code: 4 }); // Gio.IOErrorEnum.NOT_DIRECTORY
-      throw createNodeError(err, 'rmdir', path);
+      throw createNodeError(err, 'rmdir', pathStr);
     }
     // Check if empty — rmdir only removes empty directories (use rmSync for recursive)
     const enumerator = file.enumerate_children('standard::name', Gio.FileQueryInfoFlags.NONE, null);
     if (enumerator.next_file(null) !== null) {
       const err = Object.assign(new Error(), { code: 5 }); // Gio.IOErrorEnum.NOT_EMPTY
-      throw createNodeError(err, 'rmdir', path);
+      throw createNodeError(err, 'rmdir', pathStr);
     }
     file.delete(null);
   } catch (err: unknown) {
     if ((err as { code?: unknown }).code && typeof (err as { code?: unknown }).code === 'string') throw err; // Already a Node error
-    throw createNodeError(err, 'rmdir', path);
+    throw createNodeError(err, 'rmdir', pathStr);
   }
 }
 
 export function unlinkSync(path: PathLike): void {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   try {
     file.delete(null);
   } catch (err: unknown) {
-    throw createNodeError(err, 'unlink', path);
+    throw createNodeError(err, 'unlink', pathStr);
   }
 }
 
-export function writeFileSync(path: string, data: string | Uint8Array) {
-  GLib.file_set_contents(path, data);
+export function writeFileSync(path: PathLike, data: string | Uint8Array) {
+  GLib.file_set_contents(normalizePath(path), data);
 }
 
 // --- rename ---
 
 export function renameSync(oldPath: PathLike, newPath: PathLike): void {
-  const src = Gio.File.new_for_path(oldPath.toString());
-  const dest = Gio.File.new_for_path(newPath.toString());
+  const oldStr = normalizePath(oldPath);
+  const newStr = normalizePath(newPath);
+  const src = Gio.File.new_for_path(oldStr);
+  const dest = Gio.File.new_for_path(newStr);
   try {
     src.move(dest, Gio.FileCopyFlags.OVERWRITE, null, null);
   } catch (err: unknown) {
-    throw createNodeError(err, 'rename', oldPath, newPath);
+    throw createNodeError(err, 'rename', oldStr, newStr);
   }
 }
 
 // --- copyFile ---
 
 export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void {
-  const srcFile = Gio.File.new_for_path(src.toString());
-  const destFile = Gio.File.new_for_path(dest.toString());
+  const srcStr = normalizePath(src);
+  const destStr = normalizePath(dest);
+  const srcFile = Gio.File.new_for_path(srcStr);
+  const destFile = Gio.File.new_for_path(destStr);
   let flags = Gio.FileCopyFlags.NONE;
   // mode 0 = default (overwrite), COPYFILE_EXCL (1) = no overwrite
   if (mode && (mode & 1) === 0) {
@@ -336,40 +346,42 @@ export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void
   try {
     srcFile.copy(destFile, flags, null, null);
   } catch (err: unknown) {
-    throw createNodeError(err, 'copyfile', src, dest);
+    throw createNodeError(err, 'copyfile', srcStr, destStr);
   }
 }
 
 // --- access ---
 
 export function accessSync(path: PathLike, mode?: number): void {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   try {
     const info = file.query_info('access::*', Gio.FileQueryInfoFlags.NONE, null);
     // mode: F_OK=0, R_OK=4, W_OK=2, X_OK=1
     if (mode !== undefined && mode !== 0) {
       // Gio.IOErrorEnum.PERMISSION_DENIED = 14 → maps to EACCES via createNodeError
-      const permErr = { code: 14, message: `permission denied, access '${path}'` };
+      const permErr = { code: 14, message: `permission denied, access '${pathStr}'` };
       if ((mode & 4) && !info.get_attribute_boolean('access::can-read')) {
-        throw createNodeError(permErr, 'access', path);
+        throw createNodeError(permErr, 'access', pathStr);
       }
       if ((mode & 2) && !info.get_attribute_boolean('access::can-write')) {
-        throw createNodeError(permErr, 'access', path);
+        throw createNodeError(permErr, 'access', pathStr);
       }
       if ((mode & 1) && !info.get_attribute_boolean('access::can-execute')) {
-        throw createNodeError(permErr, 'access', path);
+        throw createNodeError(permErr, 'access', pathStr);
       }
     }
   } catch (err: unknown) {
     if ((err as { code?: unknown }).code && typeof (err as { code?: unknown }).code === 'string') throw err; // Already a Node-style error
-    throw createNodeError(err, 'access', path);
+    throw createNodeError(err, 'access', pathStr);
   }
 }
 
 // --- appendFile ---
 
 export function appendFileSync(path: PathLike, data: string | Uint8Array, options?: { encoding?: string; mode?: number; flag?: string } | string): void {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   let bytes: Uint8Array;
   if (typeof data === 'string') {
     bytes = new TextEncoder().encode(data);
@@ -384,19 +396,20 @@ export function appendFileSync(path: PathLike, data: string | Uint8Array, option
     }
     stream.close(null);
   } catch (err: unknown) {
-    throw createNodeError(err, 'appendfile', path);
+    throw createNodeError(err, 'appendfile', pathStr);
   }
 }
 
 // --- readlink ---
 
 export function readlinkSync(path: PathLike, options?: { encoding?: string } | string): string | Buffer {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   try {
     const info = file.query_info('standard::symlink-target', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
     const target = info.get_symlink_target();
     if (!target) {
-      throw Object.assign(new Error(`EINVAL: invalid argument, readlink '${path}'`), { code: 'EINVAL', errno: -22, syscall: 'readlink', path: path.toString() });
+      throw Object.assign(new Error(`EINVAL: invalid argument, readlink '${pathStr}'`), { code: 'EINVAL', errno: -22, syscall: 'readlink', path: pathStr });
     }
     const encoding = typeof options === 'string' ? options : options?.encoding;
     if (encoding === 'buffer') {
@@ -405,24 +418,27 @@ export function readlinkSync(path: PathLike, options?: { encoding?: string } | s
     return target;
   } catch (err: unknown) {
     if (typeof (err as { code?: unknown }).code === 'string') throw err;
-    throw createNodeError(err, 'readlink', path);
+    throw createNodeError(err, 'readlink', pathStr);
   }
 }
 
 // --- link ---
 
 export function linkSync(existingPath: PathLike, newPath: PathLike): void {
+  const existingStr = normalizePath(existingPath);
+  const newStr = normalizePath(newPath);
   // Gio doesn't have a direct hard link API, use GLib
-  const result = GLib.spawn_command_line_sync(`ln ${existingPath.toString()} ${newPath.toString()}`);
+  const result = GLib.spawn_command_line_sync(`ln ${existingStr} ${newStr}`);
   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() });
+    throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingStr}' -> '${newStr}'`), { code: 'EPERM', errno: -1, syscall: 'link', path: existingStr, dest: newStr });
   }
 }
 
 // --- truncate ---
 
 export function truncateSync(path: PathLike, len?: number): void {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   try {
     const stream = file.replace(null, false, Gio.FileCreateFlags.NONE, null);
     if (len && len > 0) {
@@ -435,35 +451,37 @@ export function truncateSync(path: PathLike, len?: number): void {
     }
     stream.close(null);
   } catch (err: unknown) {
-    throw createNodeError(err, 'truncate', path);
+    throw createNodeError(err, 'truncate', pathStr);
   }
 }
 
 // --- chmodSync ---
 
 export function chmodSync(path: PathLike, mode: Mode): void {
+  const pathStr = normalizePath(path);
   const modeNum = typeof mode === 'string' ? parseInt(mode, 8) : mode;
-  const result = GLib.spawn_command_line_sync(`chmod ${modeNum.toString(8)} ${path.toString()}`);
+  const result = GLib.spawn_command_line_sync(`chmod ${modeNum.toString(8)} ${pathStr}`);
   if (!result[0]) {
-    throw Object.assign(new Error(`EPERM: operation not permitted, chmod '${path}'`), { code: 'EPERM', errno: -1, syscall: 'chmod', path: path.toString() });
+    throw Object.assign(new Error(`EPERM: operation not permitted, chmod '${pathStr}'`), { code: 'EPERM', errno: -1, syscall: 'chmod', path: pathStr });
   }
 }
 
 // --- chownSync ---
 
 export function chownSync(path: PathLike, uid: number, gid: number): void {
-  const result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${path.toString()}`);
+  const pathStr = normalizePath(path);
+  const result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${pathStr}`);
   if (!result[0]) {
-    throw Object.assign(new Error(`EPERM: operation not permitted, chown '${path}'`), { code: 'EPERM', errno: -1, syscall: 'chown', path: path.toString() });
+    throw Object.assign(new Error(`EPERM: operation not permitted, chown '${pathStr}'`), { code: 'EPERM', errno: -1, syscall: 'chown', path: pathStr });
   }
 }
 
-export function watch(filename: string, options: { persistent?: boolean; recursive?: boolean; encoding?: string } | undefined, listener: ((eventType: string, filename: string | null) => void) | undefined) {
-  return new FSWatcher(filename, options, listener);
+export function watch(filename: PathLike, options: { persistent?: boolean; recursive?: boolean; encoding?: string } | undefined, listener: ((eventType: string, filename: string | null) => void) | undefined) {
+  return new FSWatcher(normalizePath(filename), options, listener);
 }
 
-export function openSync(path: PathLike, flags?: OpenFlags, mode?: Mode): FileHandle {
-  return new FileHandle({ path, flags, mode });
+export function openSync(path: PathLike, flags?: OpenFlags | number, mode?: Mode): FileHandle {
+  return new FileHandle({ path, flags: flags as OpenFlags | undefined, mode });
 }
 
 /**
@@ -507,7 +525,7 @@ export function mkdtempSync(prefix: string, options?: EncodingOption | BufferEnc
  * @since v14.14.0
  */
 export function rmSync(path: PathLike, options?: RmOptions): void {
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   const file = Gio.File.new_for_path(pathStr);
   const recursive = options?.recursive || false;
   const force = options?.force || false;

package/src/test.mts

@@ -1,4 +1,7 @@
-import '@gjsify/node-globals/register';
+import '@gjsify/node-globals/register/process';
+import '@gjsify/node-globals/register/buffer';
+import '@gjsify/node-globals/register/timers';
+import '@gjsify/node-globals/register/url';
 import { run } from '@gjsify/unit';
 
 import testSuiteCallback from './callback.spec.js';
@@ -12,5 +15,13 @@ import testSuiteExtended from './extended.spec.js';
 
 import testSuiteErrors from './errors.spec.js';
 import testSuiteStreams from './streams.spec.js';
+import testSuiteCp from './cp.spec.js';
+import testSuiteDir from './dir.spec.js';
+import testSuiteGlob from './glob.spec.js';
+import testSuiteWatch from './watch.spec.js';
+import testSuiteWatchFile from './watchfile.spec.js';
+import testSuiteStatFs from './statfs.spec.js';
+import testSuiteUtimes from './utimes.spec.js';
+import testSuiteFdOps from './fd-ops.spec.js';
 
-run({testSuiteCallback, testSuiteFileHandle, testSuitePromise, testSuiteSync, testSuiteSymlink, testSuiteStat, testSuiteNewApis, testSuiteExtended, testSuiteErrors, testSuiteStreams});
+run({testSuiteCallback, testSuiteFileHandle, testSuitePromise, testSuiteSync, testSuiteSymlink, testSuiteStat, testSuiteNewApis, testSuiteExtended, testSuiteErrors, testSuiteStreams, testSuiteCp, testSuiteDir, testSuiteGlob, testSuiteWatch, testSuiteWatchFile, testSuiteStatFs, testSuiteUtimes, testSuiteFdOps});

package/src/utils.ts

@@ -1,6 +1,16 @@
 // Shared filesystem utilities for GJS — original implementation using Gio
 
 import { existsSync } from './sync.js';
+import { fileURLToPath, URL as NodeURL } from 'node:url';
+
+import type { PathLike } from 'node:fs';
+
+// Gio.File.new_for_path only accepts strings; convert URL/Buffer accordingly.
+export function normalizePath(path: PathLike): string {
+  if (path instanceof URL || path instanceof NodeURL) return fileURLToPath(path as URL);
+  if (typeof path === 'string') return path;
+  return (path as Buffer).toString();
+}
 
 const CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 

package/src/utimes.spec.ts

@@ -0,0 +1,113 @@
+// Ported from refs/node-test/parallel/test-fs-utimes.js (behavior)
+// Original: MIT, Node.js contributors.
+// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
+
+import { describe, it, expect } from '@gjsify/unit';
+import { utimesSync, utimes, lutimesSync, lchownSync, promises } from 'node:fs';
+import { statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const TMP = tmpdir();
+
+function tmpFile(name: string): string {
+  const p = join(TMP, `gjsify-utimes-${name}-${process.pid}`);
+  writeFileSync(p, 'test');
+  return p;
+}
+
+export default async () => {
+  await describe('fs.utimes / fs.lutimes / fs.lchown / fs.lchmod', async () => {
+    await it('utimesSync sets mtime', async () => {
+      const f = tmpFile('mtime');
+      const mtime = new Date('2020-01-01T00:00:00Z');
+      utimesSync(f, mtime, mtime);
+      const stat = statSync(f);
+      expect(stat.mtime.getFullYear()).toBe(2020);
+      unlinkSync(f);
+    });
+
+    await it('utimesSync sets atime', async () => {
+      const f = tmpFile('atime');
+      const atime = new Date('2021-06-15T12:00:00Z');
+      const mtime = new Date('2020-01-01T00:00:00Z');
+      utimesSync(f, atime, mtime);
+      const stat = statSync(f);
+      expect(stat.mtime.getFullYear()).toBe(2020);
+      unlinkSync(f);
+    });
+
+    await it('utimes callback sets timestamps', async () => {
+      const f = tmpFile('cb');
+      const mtime = new Date('2019-03-10T00:00:00Z');
+      await new Promise<void>((resolve, reject) => {
+        utimes(f, mtime, mtime, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      const stat = statSync(f);
+      expect(stat.mtime.getFullYear()).toBe(2019);
+      unlinkSync(f);
+    });
+
+    await it('promises.utimes sets timestamps', async () => {
+      const f = tmpFile('promise');
+      const mtime = new Date('2018-08-01T00:00:00Z');
+      await promises.utimes(f, mtime, mtime);
+      const stat = statSync(f);
+      expect(stat.mtime.getFullYear()).toBe(2018);
+      unlinkSync(f);
+    });
+
+    await it('lutimesSync does not throw on a symlink', async () => {
+      const target = tmpFile('lutime-target');
+      const link = join(TMP, `gjsify-lutime-link-${process.pid}`);
+      try { unlinkSync(link); } catch {}
+      symlinkSync(target, link);
+      const mtime = new Date('2017-05-20T00:00:00Z');
+      // Just verify the call completes without throwing
+      expect(() => lutimesSync(link, mtime, mtime)).not.toThrow();
+      unlinkSync(link);
+      unlinkSync(target);
+    });
+
+    await it('lutimes callback completes without error', async () => {
+      const f = tmpFile('lutimes-cb');
+      const mtime = new Date('2016-01-01T00:00:00Z');
+      const { lutimes } = await import('node:fs') as any;
+      await new Promise<void>((resolve, reject) => {
+        lutimes(f, mtime, mtime, (err: any) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      unlinkSync(f);
+    });
+
+    await it('lchownSync does not throw (may need root to actually change)', async () => {
+      const f = tmpFile('lchown');
+      const link = join(TMP, `gjsify-lchown-link-${process.pid}`);
+      try { unlinkSync(link); } catch {}
+      symlinkSync(f, link);
+      // This will only actually change owner if running as root; just verify no throw
+      try {
+        lchownSync(link, process.getuid ? process.getuid() : 0, process.getgid ? process.getgid() : 0);
+      } catch {
+        // acceptable if kernel denies (EPERM) — just must not crash the process
+      }
+      unlinkSync(link);
+      unlinkSync(f);
+    });
+
+    await it('lchmod is a no-op (does not throw)', async () => {
+      const f = tmpFile('lchmod');
+      // Node.js removed lchmod on Linux; on GJS we export it as a no-op
+      const fsModule = await import('node:fs') as any;
+      if (typeof fsModule.lchmod === 'function') {
+        expect(() => fsModule.lchmod(f, 0o644, () => {})).not.toThrow();
+      }
+      unlinkSync(f);
+    });
+  });
+};