@zenfs/core 0.15.2 → 0.16.0

package/dist/backends/port/fs.d.ts

@@ -7,7 +7,7 @@ import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { Stats, type FileType } from '../../stats.js';
 import * as RPC from './rpc.js';
-type FileMethods = ExtractProperties<File, (...args: any[]) => Promise<any>>;
+type FileMethods = Omit<ExtractProperties<File, (...args: any[]) => Promise<any>>, typeof Symbol.asyncDispose>;
 type FileMethod = keyof FileMethods;
 export declare class PortFile extends File {
     readonly fs: PortFS;

package/dist/backends/port/fs.js

@@ -195,18 +195,10 @@ async function handleRequest(port, fs, request) {
         }
     }
     catch (e) {
-        value = e;
+        value = e instanceof ErrnoError ? e.toJSON() : e.toString();
         error = true;
     }
-    port.postMessage({
-        _zenfs: true,
-        scope,
-        id,
-        error,
-        method,
-        stack,
-        value: value instanceof ErrnoError ? value.toJSON() : value,
-    });
+    port.postMessage({ _zenfs: true, scope, id, error, method, stack, value });
 }
 export function attachFS(port, fs) {
     RPC.attach(port, request => handleRequest(port, fs, request));

package/dist/backends/port/rpc.d.ts

@@ -1,16 +1,15 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { TransferListItem } from 'worker_threads';
+import { type ErrnoErrorJSON } from '../../error.js';
 import { type PortFS } from './fs.js';
 type _MessageEvent<T = any> = T | {
     data: T;
 };
 export interface Port {
-    postMessage(value: unknown, transferList?: ReadonlyArray<TransferListItem>): void;
+    postMessage(value: unknown): void;
     on?(event: 'message', listener: (value: unknown) => void): this;
     off?(event: 'message', listener: (value: unknown) => void): this;
-    addEventListener?(type: 'message', listener: (this: Port, ev: _MessageEvent) => void): void;
-    removeEventListener?(type: 'message', listener: (this: Port, ev: _MessageEvent) => void): void;
+    addEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
+    removeEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
 }
 export interface Options {
     /**
@@ -25,27 +24,32 @@ export interface Options {
 /**
  * An RPC message
  */
-export interface Message<TScope extends string = string, TMethod extends string = string> {
+export interface Message {
     _zenfs: true;
-    scope: TScope;
+    scope: 'fs' | 'file';
     id: string;
-    method: TMethod;
+    method: string;
     stack: string;
 }
-export interface Request<TScope extends string = string, TMethod extends string = string, TArgs extends unknown[] = unknown[]> extends Message<TScope, TMethod> {
-    args: TArgs;
+export interface Request extends Message {
+    args: unknown[];
+}
+interface _ResponseWithError extends Message {
+    error: true;
+    value: ErrnoErrorJSON | string;
 }
-export interface Response<TScope extends string = string, TMethod extends string = string, TValue = unknown> extends Message<TScope, TMethod> {
-    error: boolean;
-    value: Awaited<TValue> extends File ? FileData : Awaited<TValue>;
+interface _ResponseWithValue<T> extends Message {
+    error: false;
+    value: Awaited<T> extends File ? FileData : Awaited<T>;
 }
+export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T>;
 export interface FileData {
     fd: number;
     path: string;
     position: number;
 }
 export { FileData as File };
-export declare function isMessage(arg: unknown): arg is Message<string, string>;
+export declare function isMessage(arg: unknown): arg is Message;
 type _Executor = Parameters<ConstructorParameters<typeof Promise<any>>[0]>;
 export interface Executor {
     resolve: _Executor[0];

package/dist/backends/port/rpc.js

@@ -1,4 +1,5 @@
-import { ErrnoError, Errno } from '../../error.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Errno, ErrnoError } from '../../error.js';
 import { PortFile } from './fs.js';
 function isFileData(value) {
     return typeof value == 'object' && value != null && 'fd' in value && 'path' in value && 'position' in value;
@@ -38,7 +39,7 @@ export function handleResponse(response) {
     }
     const { resolve, reject, fs } = executors.get(id);
     if (error) {
-        const e = ErrnoError.fromJSON(value);
+        const e = typeof value == 'string' ? new Error(value) : ErrnoError.fromJSON(value);
         e.stack += stack;
         reject(e);
         executors.delete(id);

package/dist/backends/store/fs.d.ts

@@ -2,7 +2,7 @@ import type { Cred } from '../../cred.js';
 import { PreloadFile } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { type Ino, Inode } from '../../inode.js';
-import { type Stats, FileType } from '../../stats.js';
+import type { FileType, Stats } from '../../stats.js';
 import type { Store, Transaction } from './store.js';
 /**
  * A file system which uses a key-value store.

package/dist/backends/store/fs.js

@@ -1,11 +1,10 @@
-import { W_OK, R_OK } from '../../emulation/constants.js';
-import { dirname, basename, join, resolve } from '../../emulation/path.js';
-import { ErrnoError, Errno } from '../../error.js';
+import { R_OK, S_IFDIR, S_IFREG, W_OK } from '../../emulation/constants.js';
+import { basename, dirname, join, resolve } from '../../emulation/path.js';
+import { Errno, ErrnoError } from '../../error.js';
 import { PreloadFile, flagToMode } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
-import { Inode, rootIno, randomIno } from '../../inode.js';
-import { FileType } from '../../stats.js';
-import { encodeDirListing, encode, decodeDirListing } from '../../utils.js';
+import { Inode, randomIno, rootIno } from '../../inode.js';
+import { decodeDirListing, encode, encodeDirListing } from '../../utils.js';
 const maxInodeAllocTries = 5;
 /**
  * A file system which uses a key-value store.
@@ -199,11 +198,11 @@ export class StoreFS extends FileSystem {
     }
     async createFile(path, flag, mode, cred) {
         const data = new Uint8Array(0);
-        const file = await this.commitNew(this.store.transaction(), path, FileType.FILE, mode, cred, data);
+        const file = await this.commitNew(this.store.transaction(), path, S_IFREG, mode, cred, data);
         return new PreloadFile(this, path, flag, file.toStats(), data);
     }
     createFileSync(path, flag, mode, cred) {
-        this.commitNewSync(path, FileType.FILE, mode, cred);
+        this.commitNewSync(path, S_IFREG, mode, cred);
         return this.openFileSync(path, flag, cred);
     }
     async openFile(path, flag, cred) {
@@ -251,10 +250,10 @@ export class StoreFS extends FileSystem {
     }
     async mkdir(path, mode, cred) {
         const tx = this.store.transaction(), data = encode('{}');
-        await this.commitNew(tx, path, FileType.DIRECTORY, mode, cred, data);
+        await this.commitNew(tx, path, S_IFDIR, mode, cred, data);
     }
     mkdirSync(path, mode, cred) {
-        this.commitNewSync(path, FileType.DIRECTORY, mode, cred, encode('{}'));
+        this.commitNewSync(path, S_IFDIR, mode, cred, encode('{}'));
     }
     async readdir(path, cred) {
         const tx = this.store.transaction();
@@ -378,7 +377,7 @@ export class StoreFS extends FileSystem {
         }
         // Create new inode. o777, owned by root:root
         const inode = new Inode();
-        inode.mode = 0o777 | FileType.DIRECTORY;
+        inode.mode = 0o777 | S_IFDIR;
         // If the root doesn't exist, the first random ID shouldn't exist either.
         await tx.set(inode.ino, encode('{}'));
         await tx.set(rootIno, inode.data);
@@ -394,7 +393,7 @@ export class StoreFS extends FileSystem {
         }
         // Create new inode, mode o777, owned by root:root
         const inode = new Inode();
-        inode.mode = 0o777 | FileType.DIRECTORY;
+        inode.mode = 0o777 | S_IFDIR;
         // If the root doesn't exist, the first random ID shouldn't exist either.
         tx.setSync(inode.ino, encode('{}'));
         tx.setSync(rootIno, inode.data);