@zenfs/core 1.0.11 → 1.1.0

package/dist/backends/file_index.js

@@ -6,7 +6,7 @@ import { NoSyncFile, isWriteable } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Readonly } from '../mixins/readonly.js';
 import { Stats } from '../stats.js';
-import { decode, encode } from '../utils.js';
+import { decodeUTF8, encodeUTF8 } from '../utils.js';
 export const version = 1;
 /**
  * An index of files
@@ -64,7 +64,7 @@ export class Index extends Map {
         for (const [path, data] of Object.entries(json.entries)) {
             const stats = new Stats(data);
             if (stats.isDirectory()) {
-                stats.fileData = encode(JSON.stringify(this.dirEntries(path)));
+                stats.fileData = encodeUTF8(JSON.stringify(this.dirEntries(path)));
             }
             this.set(path, stats);
         }
@@ -154,7 +154,7 @@ export class IndexFS extends Readonly(FileSystem) {
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', path, 'readdir');
         }
-        const content = JSON.parse(decode(stats.fileData));
+        const content = JSON.parse(decodeUTF8(stats.fileData));
         if (!Array.isArray(content)) {
             throw ErrnoError.With('ENODATA', path, 'readdir');
         }

package/dist/backends/overlay.js

@@ -51,7 +51,7 @@ import { PreloadFile, parseFlag } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Mutexed } from '../mixins/mutexed.js';
 import { Stats } from '../stats.js';
-import { decode, encode } from '../utils.js';
+import { decodeUTF8, encodeUTF8 } from '../utils.js';
 /** @internal */
 const deletionLogPath = '/.deleted';
 /**
@@ -115,7 +115,7 @@ export class UnmutexedOverlayFS extends FileSystem {
             const file = await this.writable.openFile(deletionLogPath, parseFlag('r'));
             const { size } = await file.stat();
             const { buffer } = await file.read(new Uint8Array(size));
-            this._deleteLog = decode(buffer);
+            this._deleteLog = decodeUTF8(buffer);
         }
         catch (err) {
             if (err.errno !== Errno.ENOENT) {
@@ -379,7 +379,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         this._deleteLogUpdatePending = true;
         const log = await this.writable.openFile(deletionLogPath, parseFlag('w'));
         try {
-            await log.write(encode(this._deleteLog));
+            await log.write(encodeUTF8(this._deleteLog));
             if (this._deleteLogUpdateNeeded) {
                 this._deleteLogUpdateNeeded = false;
                 await this.updateLog('');

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

@@ -1,8 +1,8 @@
-import { PreloadFile } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
 import { type Ino, Inode } from '../../inode.js';
 import type { FileType, Stats } from '../../stats.js';
 import type { Store, Transaction } from './store.js';
+import type { File } from '../../file.js';
 /**
  * A file system which uses a key-value store.
  *
@@ -34,10 +34,10 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     renameSync(oldPath: string, newPath: string): void;
     stat(path: string): Promise<Stats>;
     statSync(path: string): Stats;
-    createFile(path: string, flag: string, mode: number): Promise<PreloadFile<this>>;
-    createFileSync(path: string, flag: string, mode: number): PreloadFile<this>;
-    openFile(path: string, flag: string): Promise<PreloadFile<this>>;
-    openFileSync(path: string, flag: string): PreloadFile<this>;
+    createFile(path: string, flag: string, mode: number): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number): File;
+    openFile(path: string, flag: string): Promise<File>;
+    openFileSync(path: string, flag: string): File;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;

package/dist/backends/store/fs.js

@@ -52,7 +52,7 @@ import { Errno, ErrnoError } from '../../error.js';
 import { PreloadFile } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import { Inode, randomIno, rootIno } from '../../inode.js';
-import { decodeDirListing, encode, encodeDirListing } from '../../utils.js';
+import { decodeDirListing, encodeUTF8, encodeDirListing } from '../../utils.js';
 const maxInodeAllocTries = 5;
 /**
  * A file system which uses a key-value store.
@@ -295,10 +295,10 @@ export class StoreFS extends FileSystem {
         this.removeSync(path, true);
     }
     async mkdir(path, mode) {
-        await this.commitNew(path, S_IFDIR, mode, encode('{}'));
+        await this.commitNew(path, S_IFDIR, mode, encodeUTF8('{}'));
     }
     mkdirSync(path, mode) {
-        this.commitNewSync(path, S_IFDIR, mode, encode('{}'));
+        this.commitNewSync(path, S_IFDIR, mode, encodeUTF8('{}'));
     }
     async readdir(path) {
         const env_7 = { stack: [], error: void 0, hasError: false };
@@ -444,7 +444,7 @@ export class StoreFS extends FileSystem {
             const inode = new Inode();
             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(inode.ino, encodeUTF8('{}'));
             await tx.set(rootIno, inode.data);
             await tx.commit();
         }
@@ -472,7 +472,7 @@ export class StoreFS extends FileSystem {
             const inode = new Inode();
             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(inode.ino, encodeUTF8('{}'));
             tx.setSync(rootIno, inode.data);
             tx.commitSync();
         }

package/dist/config.d.ts

@@ -24,12 +24,20 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
     };
     /**
      * The uid to use
+     * @default 0
      */
     uid: number;
     /**
      * The gid to use
+     * @default 0
      */
     gid: number;
+    /**
+     * Whether to automatically add normal Linux devices
+     * @default false
+     * @experimental
+     */
+    addDevices: boolean;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -1,5 +1,6 @@
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import { credentials } from './credentials.js';
+import { DeviceFS, fullDevice, nullDevice, randomDevice, zeroDevice } from './devices.js';
 import * as fs from './emulation/index.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
@@ -64,6 +65,15 @@ export async function configure(configuration) {
     const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
     const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
+    if (configuration.addDevices) {
+        const devfs = new DeviceFS();
+        devfs.createDevice('/null', nullDevice);
+        devfs.createDevice('/zero', zeroDevice);
+        devfs.createDevice('/full', fullDevice);
+        devfs.createDevice('/random', randomDevice);
+        await devfs.ready();
+        fs.mount('/dev', devfs);
+    }
     if (!configuration.mounts) {
         return;
     }

package/dist/devices.d.ts

@@ -0,0 +1,158 @@
+import type { FileReadResult } from 'fs/promises';
+import { InMemoryStore } from './backends/memory.js';
+import { StoreFS } from './backends/store/fs.js';
+import { File } from './file.js';
+import type { StatsLike } from './stats.js';
+import { Stats } from './stats.js';
+import type { Ino } from './inode.js';
+/**
+ * A device
+ * @todo Maybe add major/minor number or some other device information, like a UUID?
+ * @experimental
+ */
+export interface Device {
+    /**
+     * The device's driver
+     */
+    driver: DeviceDriver;
+    /**
+     * Which inode the device is assigned
+     */
+    ino: Ino;
+}
+/**
+ * A device driver
+ * @experimental
+ */
+export interface DeviceDriver {
+    /**
+     * The name of the device driver
+     */
+    name: string;
+    /**
+     * Whether the device is buffered (a "block" device) or unbuffered (a "character" device)
+     */
+    isBuffered: boolean;
+    /**
+     * Synchronously read from the device
+     */
+    read(file: DeviceFile, buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
+    /**
+     * Synchronously write to the device
+     */
+    write(file: DeviceFile, buffer: Uint8Array, offset: number, length: number, position?: number): number;
+    /**
+     * Sync the device
+     */
+    sync?(file: DeviceFile): void;
+    /**
+     * Close the device
+     */
+    close?(file: DeviceFile): void;
+}
+/**
+ * The base class for device files
+ * This class only does some simple things:
+ * It implements `truncate` using `write` and it has non-device methods throw.
+ * It is up to device drivers to implement the rest of the functionality.
+ * @experimental
+ */
+export declare class DeviceFile extends File {
+    fs: DeviceFS;
+    readonly device: Device;
+    position: number;
+    constructor(fs: DeviceFS, path: string, device: Device);
+    get driver(): DeviceDriver;
+    protected get stats(): Partial<StatsLike>;
+    stat(): Promise<Stats>;
+    statSync(): Stats;
+    readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
+    read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number): Promise<FileReadResult<TBuffer>>;
+    writeSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
+    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number>;
+    truncate(length: number): Promise<void>;
+    truncateSync(length: number): void;
+    closeSync(): void;
+    close(): Promise<void>;
+    syncSync(): void;
+    sync(): Promise<void>;
+    chown(): Promise<void>;
+    chownSync(): void;
+    chmod(): Promise<void>;
+    chmodSync(): void;
+    utimes(): Promise<void>;
+    utimesSync(): void;
+    _setType(): Promise<void>;
+    _setTypeSync(): void;
+}
+/**
+ * @experimental
+ */
+export declare class DeviceFS extends StoreFS<InMemoryStore> {
+    protected readonly devices: Map<string, Device>;
+    createDevice(path: string, driver: DeviceDriver): Device;
+    constructor();
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    stat(path: string): Promise<Stats>;
+    statSync(path: string): Stats;
+    openFile(path: string, flag: string): Promise<File>;
+    openFileSync(path: string, flag: string): File;
+    createFile(path: string, flag: string, mode: number): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number): File;
+    unlink(path: string): Promise<void>;
+    unlinkSync(path: string): void;
+    rmdir(path: string): Promise<void>;
+    rmdirSync(path: string): void;
+    mkdir(path: string, mode: number): Promise<void>;
+    mkdirSync(path: string, mode: number): void;
+    readdir(path: string): Promise<string[]>;
+    readdirSync(path: string): string[];
+    link(target: string, link: string): Promise<void>;
+    linkSync(target: string, link: string): void;
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}
+/**
+ * Simulates the `/dev/null` device.
+ * - Reads return 0 bytes (EOF).
+ * - Writes discard data, advancing the file position.
+ * @experimental
+ */
+export declare const nullDevice: DeviceDriver;
+/**
+ * Simulates the `/dev/zero` device
+ * Provides an infinite stream of zeroes when read.
+ * Discards any data written to it.
+ *
+ * - Reads fill the buffer with zeroes.
+ * - Writes discard data but update the file position.
+ * - Provides basic file metadata, treating it as a character device.
+ * @experimental
+ */
+export declare const zeroDevice: DeviceDriver;
+/**
+ * Simulates the `/dev/full` device.
+ * - Reads behave like `/dev/zero` (returns zeroes).
+ * - Writes always fail with ENOSPC (no space left on device).
+ * @experimental
+ */
+export declare const fullDevice: DeviceDriver;
+/**
+ * Simulates the `/dev/random` device.
+ * - Reads return random bytes.
+ * - Writes discard data, advancing the file position.
+ * @experimental
+ */
+export declare const randomDevice: DeviceDriver;
+/**
+ * Shortcuts for importing.
+ * @experimental
+ */
+declare const _default: {
+    null: DeviceDriver;
+    zero: DeviceDriver;
+    full: DeviceDriver;
+    random: DeviceDriver;
+};
+export default _default;