@zenfs/core 1.11.4 → 2.1.0

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

@@ -1,7 +1,8 @@
+import type { UUID } from 'node:crypto';
 import { Resource } from 'utilium/cache.js';
+import type { UsageInfo } from '../../internal/filesystem.js';
 import '../../polyfills.js';
 import type { StoreFS } from './fs.js';
-import type { UsageInfo } from '../../internal/filesystem.js';
 /**
  * @category Stores and Transactions
  */
@@ -16,7 +17,7 @@ export interface Store {
     /**
      * @see FileSystem#id
      */
-    readonly id?: number;
+    readonly type?: number;
     /**
      * What the file system using this store should be called.
      * For example, tmpfs for an in memory store
@@ -28,19 +29,13 @@ export interface Store {
      */
     readonly label?: string;
     /**
-     * Syncs the store
-     */
-    sync(): Promise<void>;
-    /**
-     * Empties the store completely.
-     * @deprecated
+     * A UUID for this instance of the store.
      */
-    clear?(): Promise<void> | void;
+    readonly uuid?: UUID;
     /**
-     * Empties the store completely.
-     * @deprecated
+     * Syncs the store
      */
-    clearSync?(): void;
+    sync(): Promise<void>;
     /**
      * Begins a new transaction.
      */
@@ -56,7 +51,7 @@ export interface Store {
     /**
      * @internal @hidden
      */
-    _fs?: StoreFS;
+    fs?: StoreFS;
 }
 /**
  * A transaction for a store.
@@ -174,8 +169,8 @@ export declare class WrappedTransaction<T extends Store = Store> {
     keys(): Promise<Iterable<number>>;
     get(id: number, offset?: number, end?: number): Promise<Uint8Array | undefined>;
     getSync(id: number, offset?: number, end?: number): Uint8Array | undefined;
-    set(id: number, data: Uint8Array, offset?: number): Promise<void>;
-    setSync(id: number, data: Uint8Array, offset?: number): void;
+    set(id: number, view: Uint8Array | ArrayBufferView, offset?: number): Promise<void>;
+    setSync(id: number, view: Uint8Array | ArrayBufferView, offset?: number): void;
     remove(id: number): Promise<void>;
     removeSync(id: number): void;
     commit(): Promise<void>;

package/dist/backends/store/store.js

@@ -1,6 +1,6 @@
+import { withErrno } from 'kerium';
+import { warn } from 'kerium/log';
 import { Resource } from 'utilium/cache.js';
-import { ErrnoError } from '../../internal/error.js';
-import { err, warn } from '../../internal/log.js';
 import '../../polyfills.js';
 /**
  * A transaction for a store.
@@ -62,7 +62,6 @@ export class AsyncTransaction extends Transaction {
         return resource;
     }
     getSync(id, offset, end) {
-        var _a;
         const resource = this._cached(id);
         if (!resource)
             return;
@@ -72,7 +71,7 @@ export class AsyncTransaction extends Transaction {
             this.async(this.get(id, start, end));
         }
         if (missing.length)
-            throw err(ErrnoError.With('EAGAIN', (_a = this.store._fs) === null || _a === void 0 ? void 0 : _a._path(id)));
+            throw withErrno('EAGAIN');
         const region = resource.regionAt(offset);
         if (!region) {
             warn('Missing cache region for ' + id);
@@ -130,13 +129,15 @@ export class WrappedTransaction {
         this.stash(id);
         return data;
     }
-    async set(id, data, offset = 0) {
-        await this.markModified(id, offset, data.byteLength);
-        await this.raw.set(id, data, offset);
+    async set(id, view, offset = 0) {
+        await this.markModified(id, offset, view.byteLength);
+        const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        await this.raw.set(id, buffer, offset);
     }
-    setSync(id, data, offset = 0) {
-        this.markModifiedSync(id, offset, data.byteLength);
-        this.raw.setSync(id, data, offset);
+    setSync(id, view, offset = 0) {
+        this.markModifiedSync(id, offset, view.byteLength);
+        const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        this.raw.setSync(id, buffer, offset);
     }
     async remove(id) {
         await this.markModified(id, 0, undefined);

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 import type { Device, DeviceDriver } from './internal/devices.js';
-import type { LogConfiguration } from './internal/log.js';
+import { log } from 'kerium';
 /**
  * Configuration for a specific mount point
  * @category Backends and Configuration
@@ -52,28 +52,19 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     disableAccessChecks: boolean;
-    /**
-     * If true, disables `read` and `readSync` from updating the atime.
-     *
-     * This can increase performance.
-     * @experimental
-     * @default false
-     */
-    disableUpdateOnRead: boolean;
     /**
      * If true, files will only sync to the file system when closed.
+     * This overrides `disableUpdateOnRead`
      *
      * This can increase performance.
      * @experimental
-     * @overrides `disableUpdateOnRead`
      * @default false
      */
     onlySyncOnClose: boolean;
     /**
      * Configurations options for the log.
-     * @experimental
      */
-    log: LogConfiguration;
+    log: log.Configuration;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -1,10 +1,10 @@
+import { log, withErrno } from 'kerium';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
-import { useCredentials } from './internal/credentials.js';
+import { defaultContext } from './internal/contexts.js';
+import { createCredentials } from './internal/credentials.js';
 import { DeviceFS } from './internal/devices.js';
-import { Errno, ErrnoError } from './internal/error.js';
 import { FileSystem } from './internal/filesystem.js';
-import { configure as configureLog, crit, err, info } from './internal/log.js';
-import { config } from './vfs/config.js';
+import { _setAccessChecks } from './vfs/config.js';
 import * as fs from './vfs/index.js';
 import { mounts } from './vfs/shared.js';
 function isMountConfig(arg) {
@@ -17,10 +17,10 @@ function isMountConfig(arg) {
  */
 export async function resolveMountConfig(configuration, _depth = 0) {
     if (typeof configuration !== 'object' || configuration == null) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration'));
+        throw log.err(withErrno('EINVAL', 'Invalid options on mount configuration'));
     }
     if (!isMountConfig(configuration)) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Invalid mount configuration'));
+        throw log.err(withErrno('EINVAL', 'Invalid mount configuration'));
     }
     if (configuration instanceof FileSystem) {
         await configuration.ready();
@@ -34,20 +34,20 @@ export async function resolveMountConfig(configuration, _depth = 0) {
             continue;
         if (!isMountConfig(value))
             continue;
-        info('Resolving nested mount configuration: ' + key);
+        log.info('Resolving nested mount configuration: ' + key);
         if (_depth > 10) {
-            throw err(new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite'));
+            throw log.err(withErrno('EINVAL', 'Invalid configuration, too deep and possibly infinite'));
         }
         configuration[key] = await resolveMountConfig(value, ++_depth);
     }
     const { backend } = configuration;
-    if (typeof backend.isAvailable == 'function' && !(await backend.isAvailable())) {
-        throw err(new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend.name));
+    if (typeof backend.isAvailable == 'function' && !(await backend.isAvailable(configuration))) {
+        throw log.err(withErrno('EPERM', 'Backend not available: ' + backend.name));
     }
-    await checkOptions(backend, configuration);
+    checkOptions(backend, configuration);
     const mount = (await backend.create(configuration));
     if (configuration.disableAsyncCache)
-        mount.attributes.set('no_async');
+        mount.attributes.set('no_async_preload');
     await mount.ready();
     return mount;
 }
@@ -79,7 +79,7 @@ async function mount(path, mount) {
         await fs.promises.mkdir(path, { recursive: true });
     }
     else if (!stats.isDirectory()) {
-        throw ErrnoError.With('ENOTDIR', path, 'configure');
+        throw withErrno('ENOTDIR', 'Missing directory at mount point: ' + path);
     }
     fs.mount(path, mount);
 }
@@ -89,7 +89,7 @@ async function mount(path, mount) {
 export function addDevice(driver, options) {
     const devfs = mounts.get('/dev');
     if (!(devfs instanceof DeviceFS))
-        throw crit(new ErrnoError(Errno.ENOTSUP, '/dev does not exist or is not a device file system'));
+        throw log.crit(withErrno('ENOTSUP', '/dev does not exist or is not a device file system'));
     return devfs._createDevice(driver, options);
 }
 /**
@@ -101,12 +101,10 @@ export async function configure(configuration) {
     var _a;
     const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
     const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
-    useCredentials({ uid, gid });
-    config.checkAccess = !configuration.disableAccessChecks;
-    config.updateOnRead = !configuration.disableUpdateOnRead;
-    config.syncImmediately = !configuration.onlySyncOnClose;
+    Object.assign(defaultContext.credentials, createCredentials({ uid, gid }));
+    _setAccessChecks(!configuration.disableAccessChecks);
     if (configuration.log)
-        configureLog(configuration.log);
+        log.configure(configuration.log);
     if (configuration.mounts) {
         // sort to make sure any root replacement is done first
         for (const [_point, mountConfig] of Object.entries(configuration.mounts).sort(([a], [b]) => (a.length > b.length ? 1 : -1))) {

package/dist/context.d.ts

@@ -1,27 +1,14 @@
-import type { CredentialInit, Credentials } from './internal/credentials.js';
-import * as fs from './vfs/index.js';
+import type { BoundContext, ContextInit, FSContext, V_Context } from './internal/contexts.js';
+export type { BoundContext, ContextInit, FSContext, V_Context };
 /**
- * Represents some context used for FS operations
- * @category Backends and Configuration
+ * A map of all contexts.
+ * @internal
+ * @category Contexts
  */
-export interface FSContext {
-    root: string;
-    readonly credentials: Credentials;
-}
-/**
- * maybe an FS context
- */
-export type V_Context = void | (Partial<FSContext> & object);
-/**
- * Allows you to restrict operations to a specific root path and set of credentials.
- * @category Backends and Configuration
- */
-export interface BoundContext extends FSContext {
-    fs: typeof fs;
-}
+export declare const boundContexts: Map<number, BoundContext>;
 /**
  * Allows you to restrict operations to a specific root path and set of credentials.
  * Note that the default credentials of a bound context are copied from the global credentials.
- * @category Backends and Configuration
+ * @category Contexts
  */
-export declare function bindContext(root: string, credentials?: CredentialInit): BoundContext;
+export declare function bindContext(this: void | null | FSContext, { root, pwd, credentials }?: ContextInit): BoundContext;

package/dist/context.js

@@ -1,23 +1,46 @@
-import { createCredentials, credentials as defaultCredentials } from './internal/credentials.js';
+import { bindFunctions } from 'utilium';
+import { defaultContext } from './internal/contexts.js';
+import { createCredentials } from './internal/credentials.js';
+import * as path from './path.js';
 import * as fs from './vfs/index.js';
+// 0 is reserved for the global/default context
+let _nextId = 1;
 /**
- * Binds a this value for all of the functions in an object (not recursive)
+ * A map of all contexts.
  * @internal
+ * @category Contexts
  */
-function _bindFunctions(fns, thisValue) {
-    return Object.fromEntries(Object.entries(fns).map(([k, v]) => [k, typeof v == 'function' ? v.bind(thisValue) : v]));
-}
+export const boundContexts = new Map();
 /**
  * Allows you to restrict operations to a specific root path and set of credentials.
  * Note that the default credentials of a bound context are copied from the global credentials.
- * @category Backends and Configuration
+ * @category Contexts
  */
-export function bindContext(root, credentials = structuredClone(defaultCredentials)) {
+export function bindContext({ root = (this === null || this === void 0 ? void 0 : this.root) || '/', pwd = (this === null || this === void 0 ? void 0 : this.pwd) || '/', credentials = structuredClone(defaultContext.credentials) } = {}) {
+    const parent = this !== null && this !== void 0 ? this : defaultContext;
     const ctx = {
+        id: _nextId++,
         root,
+        pwd,
         credentials: createCredentials(credentials),
+        descriptors: new Map(),
+        parent,
+        children: [],
+    };
+    const bound = {
+        ...ctx,
+        fs: {
+            ...bindFunctions(fs, ctx),
+            promises: bindFunctions(fs.promises, ctx),
+            xattr: bindFunctions(fs.xattr, ctx),
+        },
+        path: bindFunctions(path, ctx),
+        bind: (init) => {
+            const child = bindContext.call(ctx, init);
+            ctx.children.push(child);
+            return child;
+        },
     };
-    const fn_fs = _bindFunctions(fs, ctx);
-    const fn_promises = _bindFunctions(fs.promises, ctx);
-    return { ...ctx, fs: { ...fs, ...fn_fs, promises: { ...fs.promises, ...fn_promises } } };
+    boundContexts.set(ctx.id, bound);
+    return bound;
 }

package/dist/index.d.ts

@@ -3,8 +3,9 @@ export * from './config.js';
 export * from './context.js';
 export * from './internal/index.js';
 export * from './mixins/index.js';
-export * from './stats.js';
+export * from './vfs/stats.js';
 export * from './utils.js';
+export { mounts } from './vfs/shared.js';
 export * from './vfs/index.js';
 export { fs };
 import * as fs from './vfs/index.js';

package/dist/index.js

@@ -3,8 +3,9 @@ export * from './config.js';
 export * from './context.js';
 export * from './internal/index.js';
 export * from './mixins/index.js';
-export * from './stats.js';
+export * from './vfs/stats.js';
 export * from './utils.js';
+export { mounts } from './vfs/shared.js';
 export * from './vfs/index.js';
 export { fs };
 import * as fs from './vfs/index.js';

package/dist/internal/contexts.d.ts

@@ -0,0 +1,63 @@
+import type { Bound } from 'utilium';
+import type * as path from '../path.js';
+import type { SyncHandle } from '../vfs/file.js';
+import type * as fs from '../vfs/index.js';
+import type { Credentials, CredentialsInit } from './credentials.js';
+/**
+ * A context used for FS operations
+ * @category Contexts
+ */
+export interface FSContext {
+    /** The unique ID of the context */
+    readonly id: number;
+    /**
+     * The absolute root path of the context
+     *
+     * Note the parent's root is not considered
+     */
+    root: string;
+    /** The current working directory of the context */
+    pwd: string;
+    /** The credentials of the context, used for access checks */
+    readonly credentials: Credentials;
+    /** A map of open file descriptors to their handles */
+    descriptors: Map<number, SyncHandle>;
+    /** The parent context, if any. */
+    parent: V_Context;
+    /** The child contexts */
+    children: FSContext[];
+}
+/**
+ * maybe an FS context
+ */
+export type V_Context = void | null | (Partial<FSContext> & object);
+/**
+ * Allows you to restrict operations to a specific root path and set of credentials.
+ * @category Contexts
+ */
+export interface BoundContext extends FSContext {
+    fs: Bound<typeof fs, FSContext> & {
+        promises: Bound<typeof fs.promises, FSContext>;
+        xattr: Bound<typeof fs.xattr, FSContext>;
+    };
+    /** Path functions, bound to the context */
+    path: Bound<typeof path, FSContext>;
+    /** Creates a new child context with this context as the parent */
+    bind(init: ContextInit): BoundContext;
+    /** The parent context, if any. */
+    parent: FSContext;
+}
+/**
+ * @category Contexts
+ */
+export interface ContextInit {
+    root?: string;
+    pwd?: string;
+    credentials?: CredentialsInit;
+}
+/**
+ * The default/global context.
+ * @internal @hidden
+ * @category Contexts
+ */
+export declare const defaultContext: FSContext;

package/dist/internal/contexts.js

@@ -0,0 +1,15 @@
+import { createCredentials } from './credentials.js';
+/**
+ * The default/global context.
+ * @internal @hidden
+ * @category Contexts
+ */
+export const defaultContext = {
+    id: 0,
+    root: '/',
+    pwd: '/',
+    credentials: createCredentials({ uid: 0, gid: 0 }),
+    descriptors: new Map(),
+    parent: null,
+    children: [],
+};

package/dist/internal/credentials.d.ts

@@ -16,24 +16,15 @@ export interface Credentials {
      */
     groups: number[];
 }
-/**
- * @category Internals
- */
-export declare const credentials: Credentials;
 /**
  * Initialization for a set of credentials
  * @category Internals
  */
-export interface CredentialInit extends Partial<Credentials> {
+export interface CredentialsInit extends Partial<Credentials> {
     uid: number;
     gid: number;
 }
 /**
  * @category Internals
  */
-export declare function createCredentials(source: CredentialInit): Credentials;
-/**
- * Uses credentials from the provided uid and gid.
- * @category Internals
- */
-export declare function useCredentials(source: CredentialInit): void;
+export declare function createCredentials(source: CredentialsInit): Credentials;

package/dist/internal/credentials.js

@@ -1,15 +1,3 @@
-/**
- * @category Internals
- */
-export const credentials = {
-    uid: 0,
-    gid: 0,
-    suid: 0,
-    sgid: 0,
-    euid: 0,
-    egid: 0,
-    groups: [],
-};
 /**
  * @category Internals
  */
@@ -23,10 +11,3 @@ export function createCredentials(source) {
         ...source,
     };
 }
-/**
- * Uses credentials from the provided uid and gid.
- * @category Internals
- */
-export function useCredentials(source) {
-    Object.assign(credentials, createCredentials(source));
-}

package/dist/internal/devices.d.ts

@@ -1,10 +1,7 @@
 import { InMemoryStore } from '../backends/memory.js';
 import { StoreFS } from '../backends/store/fs.js';
-import { Stats } from '../stats.js';
-import type { FileReadResult } from './file.js';
-import { File } from './file.js';
 import type { CreationOptions } from './filesystem.js';
-import { Inode } from './inode.js';
+import { Inode, type InodeLike } from './inode.js';
 /**
  * A device
  * @todo Maybe add some other device information, like a UUID?
@@ -18,9 +15,9 @@ export interface Device<TData = any> {
      */
     driver: DeviceDriver<TData>;
     /**
-     * Which inode the device is assigned
+     * Device metadata
      */
-    ino: number;
+    inode: Inode;
     /**
      * Data associated with a device.
      * This is meant to be used by device drivers.
@@ -43,6 +40,7 @@ export interface DeviceInit<TData = any> {
     minor?: number;
     major?: number;
     name?: string;
+    metadata?: Partial<InodeLike>;
 }
 /**
  * A device driver
@@ -58,89 +56,34 @@ export interface DeviceDriver<TData = any> {
      * Note that if this is unset or false, auto-named devices will have a number suffix
      */
     singleton?: boolean;
-    /**
-     * Whether the device is buffered (a "block" device) or unbuffered (a "character" device)
-     * @default false
-     */
-    isBuffered?: boolean;
     /**
      * Initializes a new device.
      * @returns `Device.data`
      */
     init?(ino: number, options: object): DeviceInit<TData>;
-    /**
-     * Synchronously read from a device file
-     * @group File operations
-     * @deprecated
-     * @todo [BREAKING] Remove
-     */
-    read?(file: DeviceFile<TData>, buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
     /**
      * Synchronously read from a device.
      * @privateRemarks
      * For many devices there is no concept of an offset or end.
      * For example, /dev/random will be "the same" regardless of where you read from- random data.
      * @group File operations
-     * @todo [BREAKING] Rename to `read`
      */
-    readD(device: Device<TData>, buffer: Uint8Array, offset: number, end: number): void;
-    /**
-     * Synchronously write to a device file
-     * @group File operations
-     * @deprecated
-     * @todo [BREAKING] Remove
-     */
-    write?(file: DeviceFile<TData>, buffer: Uint8Array, offset: number, length: number, position?: number): number;
+    read(device: Device<TData>, buffer: Uint8Array, offset: number, end: number): void;
     /**
      * Synchronously write to a device
      * @group File operations
-     * @todo [BREAKING] Rename to `write`
      */
-    writeD(device: Device<TData>, buffer: Uint8Array, offset: number): void;
+    write(device: Device<TData>, buffer: Uint8Array, offset: number): void;
     /**
      * Sync the device
      * @group File operations
      */
-    sync?(file: DeviceFile<TData>): void;
+    sync?(device: Device<TData>): void;
     /**
      * Close the device
      * @group File operations
      */
-    close?(file: DeviceFile<TData>): 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.
- * @category Internals
- * @internal
- */
-export declare class DeviceFile<TData = any> extends File {
-    fs: DeviceFS;
-    readonly device: Device<TData>;
-    position: number;
-    constructor(fs: DeviceFS, path: string, device: Device<TData>);
-    get driver(): DeviceDriver<TData>;
-    protected stats: Inode;
-    stat(): Promise<Stats>;
-    statSync(): Stats;
-    readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
-    read<TBuffer extends 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;
+    close?(file: Device<TData>): void;
 }
 /**
  * A temporary file system that manages and interfaces with devices
@@ -148,11 +91,6 @@ export declare class DeviceFile<TData = any> extends File {
  */
 export declare class DeviceFS extends StoreFS<InMemoryStore> {
     protected readonly devices: Map<string, Device<any>>;
-    /**
-     * Creates a new device at `path` relative to the `DeviceFS` root.
-     * @deprecated
-     */
-    createDevice<TData = any>(path: string, driver: DeviceDriver<TData>, options?: object): Device<TData | Record<string, never>>;
     protected devicesWithDriver(driver: DeviceDriver<unknown> | string, forceIdentity?: boolean): Device[];
     /**
      * @internal
@@ -165,24 +103,24 @@ export declare class DeviceFS extends StoreFS<InMemoryStore> {
     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, options: CreationOptions): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    stat(path: string): Promise<InodeLike>;
+    statSync(path: string): InodeLike;
+    touch(path: string, metadata: InodeLike): Promise<void>;
+    touchSync(path: string, metadata: InodeLike): void;
+    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
+    createFileSync(path: string, options: CreationOptions): InodeLike;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     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;
+    sync(): Promise<void>;
+    syncSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, data: Uint8Array, offset: number): Promise<void>;