@zenfs/core 1.8.8 → 1.9.0

package/dist/backends/backend.d.ts

@@ -1,5 +1,5 @@
 import type { RequiredKeys } from 'utilium';
-import type { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../internal/filesystem.js';
 type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | (abstract new (...args: any[]) => any);
 /**
  * Resolves the type of Backend.options from the options interface

package/dist/backends/backend.js

@@ -1,4 +1,5 @@
-import { Errno, ErrnoError } from '../error.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { debug, err } from '../internal/log.js';
 /** @internal */
 export function isBackend(arg) {
     return arg != null && typeof arg == 'object' && 'create' in arg && typeof arg.create == 'function';
@@ -9,16 +10,17 @@ export function isBackend(arg) {
  */
 export async function checkOptions(backend, options) {
     if (typeof options != 'object' || options === null) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid options');
+        throw err(new ErrnoError(Errno.EINVAL, 'Invalid options'));
     }
     // Check for required options.
     for (const [optName, opt] of Object.entries(backend.options)) {
         const value = options === null || options === void 0 ? void 0 : options[optName];
         if (value === undefined || value === null) {
             if (!opt.required) {
+                debug('Missing non-required option: ' + optName);
                 continue;
             }
-            throw new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName);
+            throw err(new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName));
         }
         const isType = (type, _ = value) => (typeof type == 'function' ? value instanceof type : typeof value === type);
         if (Array.isArray(opt.type) ? !opt.type.some(v => isType(v)) : !isType(opt.type)) {
@@ -27,8 +29,9 @@ export async function checkOptions(backend, options) {
             // The expected type (as a string)
             const name = (type) => (typeof type == 'function' ? type.name : type);
             const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
-            throw new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`);
+            throw err(new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`));
         }
+        debug('Using custom validator for option: ' + optName);
         if (opt.validator)
             await opt.validator(value);
         // Otherwise: All good!

package/dist/backends/fetch.d.ts

@@ -1,10 +1,11 @@
-import { StoreFS } from './store/fs.js';
-import { type IndexData } from './store/file_index.js';
-import type { Store } from './store/store.js';
+import type { IndexData } from '../internal/file_index.js';
+import { Index } from '../internal/file_index.js';
+import { IndexFS } from '../internal/index_fs.js';
+import type { SharedConfig } from './backend.js';
 /**
  * Configuration options for FetchFS.
  */
-export interface FetchOptions {
+export interface FetchOptions extends SharedConfig {
     /**
      * Options to pass through to fetch calls
      */
@@ -19,36 +20,26 @@ export interface FetchOptions {
      */
     baseUrl?: string;
     /**
-     * A store to use for caching content.
-     * Defaults to an in-memory store
+     * If true, enables writing to the remote (using post and delete)
+     * @default false
      */
-    cache?: Store;
+    remoteWrite?: boolean;
 }
 /**
  * A simple filesystem backed by HTTP using the `fetch` API.
- *
- *
- * Index objects look like the following:
- *
- * ```json
- * {
- * 	"version": 1,
- * 	"entries": {
- * 		"/home": { ... },
- * 		"/home/john": { ... },
- * 		"/home/james": { ... }
- * 	}
- * }
- * ```
- *
- * Each entry contains the stats associated with the file.
+ * @internal
  */
-export declare class FetchFS extends StoreFS {
-    readonly baseUrl: string;
-    readonly requestInit?: RequestInit | undefined;
-    private indexData;
-    ready(): Promise<void>;
-    constructor(index?: IndexData | string, cache?: Store, baseUrl?: string, requestInit?: RequestInit | undefined);
+export declare class FetchFS extends IndexFS {
+    protected baseUrl: string;
+    protected requestInit: RequestInit;
+    protected remoteWrite?: boolean | undefined;
+    constructor(index: Index, baseUrl: string, requestInit?: RequestInit, remoteWrite?: boolean | undefined);
+    protected remove(path: string): Promise<void>;
+    protected removeSync(path: string): void;
+    read(path: string, buffer: Uint8Array, offset: number | undefined, end: number): Promise<void>;
+    readSync(path: string, buffer: Uint8Array, offset: number | undefined, end: number): void;
+    write(path: string, data: Uint8Array, offset: number): Promise<void>;
+    writeSync(path: string, data: Uint8Array, offset: number): void;
 }
 declare const _Fetch: {
     readonly name: "Fetch";
@@ -65,13 +56,13 @@ declare const _Fetch: {
             readonly type: "object";
             readonly required: false;
         };
-        readonly cache: {
-            readonly type: "object";
+        readonly remoteWrite: {
+            readonly type: "boolean";
             readonly required: false;
         };
     };
     readonly isAvailable: () => boolean;
-    readonly create: (options: FetchOptions) => FetchFS;
+    readonly create: (options: FetchOptions) => Promise<FetchFS>;
 };
 type _Fetch = typeof _Fetch;
 export interface Fetch extends _Fetch {

package/dist/backends/fetch.js

@@ -1,142 +1,80 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { Errno, ErrnoError } from '../error.js';
+import * as requests from 'utilium/requests.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { Index } from '../internal/file_index.js';
+import { IndexFS } from '../internal/index_fs.js';
+import { err, warn } from '../internal/log.js';
+import { decodeUTF8, normalizePath } from '../utils.js';
 import { S_IFREG } from '../vfs/constants.js';
-import { InMemoryStore } from './memory.js';
-import { StoreFS } from './store/fs.js';
-import { Index } from './store/file_index.js';
-import { normalizePath } from '../utils.js';
-async function fetchFile(path, type, init) {
-    const response = await fetch(path, init).catch((e) => {
-        throw new ErrnoError(Errno.EIO, e.message, path);
-    });
-    if (!response.ok) {
-        throw new ErrnoError(Errno.EIO, 'fetch failed: response returned code ' + response.status, path);
-    }
-    switch (type) {
-        case 'buffer': {
-            const arrayBuffer = await response.arrayBuffer().catch((e) => {
-                throw new ErrnoError(Errno.EIO, e.message, path);
-            });
-            return new Uint8Array(arrayBuffer);
+/** Parse and throw */
+function parseError(path, fs) {
+    return (error) => {
+        if (!('tag' in error))
+            throw err(new ErrnoError(Errno.EIO, error.stack, path), { fs });
+        switch (error.tag) {
+            case 'fetch':
+                throw err(new ErrnoError(Errno.EREMOTEIO, error.message, path), { fs });
+            case 'status':
+                throw err(new ErrnoError(error.response.status > 500 ? Errno.EREMOTEIO : Errno.EIO, 'Response status code is ' + error.response.status, path), { fs });
+            case 'size':
+                throw err(new ErrnoError(Errno.EBADE, error.message, path), { fs });
+            case 'buffer':
+                throw err(new ErrnoError(Errno.EIO, 'Failed to decode buffer', path), { fs });
         }
-        case 'json':
-            return response.json().catch((e) => {
-                throw new ErrnoError(Errno.EIO, e.message, path);
-            });
-        default:
-            throw new ErrnoError(Errno.EINVAL, 'Invalid download type: ' + type);
-    }
+    };
 }
 /**
  * A simple filesystem backed by HTTP using the `fetch` API.
- *
- *
- * Index objects look like the following:
- *
- * ```json
- * {
- * 	"version": 1,
- * 	"entries": {
- * 		"/home": { ... },
- * 		"/home/john": { ... },
- * 		"/home/james": { ... }
- * 	}
- * }
- * ```
- *
- * Each entry contains the stats associated with the file.
+ * @internal
  */
-export class FetchFS extends StoreFS {
-    async ready() {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            if (this._initialized)
-                return;
-            await super.ready();
-            const index = new Index();
-            index.fromJSON(await this.indexData);
-            await this.loadIndex(index);
-            if (this._disableSync)
-                return;
-            const tx = __addDisposableResource(env_1, this.store.transaction(), true);
-            // Iterate over all of the files and cache their contents
-            for (const [path, node] of index) {
-                if (!(node.mode & S_IFREG))
-                    continue;
-                const content = await fetchFile(this.baseUrl + path, 'buffer', this.requestInit);
-                await tx.set(node.data, content);
-            }
-            await tx.commit();
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
-    }
-    constructor(index = 'index.json', cache = new InMemoryStore('fetch'), baseUrl = '', requestInit) {
-        super(cache);
+export class FetchFS extends IndexFS {
+    constructor(index, baseUrl, requestInit = {}, remoteWrite) {
+        super(0x206e6673, 'nfs', index);
         this.baseUrl = baseUrl;
         this.requestInit = requestInit;
-        // prefix url must end in a directory separator.
-        if (baseUrl.at(-1) == '/')
-            this.baseUrl = baseUrl.slice(0, -1);
-        this.indexData = typeof index != 'string' ? index : fetchFile(index, 'json', requestInit);
+        this.remoteWrite = remoteWrite;
+    }
+    async remove(path) {
+        await requests.remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit);
+    }
+    removeSync(path) {
+        void requests.remove(this.baseUrl + path, { warn, cacheOnly: !this.remoteWrite }, this.requestInit);
+    }
+    async read(path, buffer, offset = 0, end) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'read');
+        end !== null && end !== void 0 ? end : (end = inode.size);
+        if (end - offset == 0)
+            return;
+        const data = await requests
+            .get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }, this.requestInit)
+            .catch(parseError(path, this))
+            .catch(() => undefined);
+        if (!data)
+            throw ErrnoError.With('ENODATA', path, 'read');
+        buffer.set(data);
+    }
+    readSync(path, buffer, offset = 0, end) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'read');
+        end !== null && end !== void 0 ? end : (end = inode.size);
+        if (end - offset == 0)
+            return;
+        const { data, missing } = requests.getCached(this.baseUrl + path, { start: offset, end, size: inode.size, warn });
+        if (!data)
+            throw ErrnoError.With('ENODATA', path, 'read');
+        if (missing.length) {
+            void requests.get(this.baseUrl + path, { start: offset, end, size: inode.size, warn });
+            throw ErrnoError.With('EAGAIN', path, 'read');
+        }
+        buffer.set(data);
+    }
+    async write(path, data, offset) {
+        await requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError(path, this));
+    }
+    writeSync(path, data, offset) {
+        void requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError(path, this));
     }
 }
 const _Fetch = {
@@ -145,15 +83,37 @@ const _Fetch = {
         index: { type: ['string', 'object'], required: false },
         baseUrl: { type: 'string', required: false },
         requestInit: { type: 'object', required: false },
-        cache: { type: 'object', required: false },
+        remoteWrite: { type: 'boolean', required: false },
     },
     isAvailable() {
         return typeof globalThis.fetch == 'function';
     },
-    create(options) {
+    async create(options) {
+        var _a;
         const url = new URL(options.baseUrl || '');
         url.pathname = normalizePath(url.pathname);
-        return new FetchFS(options.index, options.cache, url.toString(), options.requestInit);
+        let baseUrl = url.toString();
+        if (baseUrl.at(-1) == '/')
+            baseUrl = baseUrl.slice(0, -1);
+        (_a = options.index) !== null && _a !== void 0 ? _a : (options.index = 'index.json');
+        const index = new Index();
+        if (typeof options.index != 'string') {
+            index.fromJSON(options.index);
+        }
+        else {
+            const data = await requests.get(options.index, { warn }, options.requestInit).catch(parseError());
+            index.fromJSON(JSON.parse(decodeUTF8(data)));
+        }
+        const fs = new FetchFS(index, baseUrl, options.requestInit, options.remoteWrite);
+        if (options.disableAsyncCache)
+            return fs;
+        // Iterate over all of the files and cache their contents
+        for (const [path, node] of index) {
+            if (!(node.mode & S_IFREG))
+                continue;
+            await requests.get(baseUrl + path, { warn }, options.requestInit).catch(parseError(path, fs));
+        }
+        return fs;
     },
 };
 export const Fetch = _Fetch;

package/dist/backends/index.d.ts

@@ -5,8 +5,5 @@ export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
 export * from './store/fs.js';
-export * from './store/file_index.js';
-export * from './store/index_fs.js';
-export * from './store/inode.js';
-export * from './store/simple.js';
+export * from './store/map.js';
 export * from './store/store.js';

package/dist/backends/index.js

@@ -5,8 +5,5 @@ export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
 export * from './store/fs.js';
-export * from './store/file_index.js';
-export * from './store/index_fs.js';
-export * from './store/inode.js';
-export * from './store/simple.js';
+export * from './store/map.js';
 export * from './store/store.js';

package/dist/backends/memory.d.ts

@@ -1,14 +1,16 @@
 import { StoreFS } from './store/fs.js';
-import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
+import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
 /**
  * A simple in-memory store
  */
-export declare class InMemoryStore extends Map<number, Uint8Array> implements SimpleSyncStore {
-    name: string;
-    constructor(name?: string);
+export declare class InMemoryStore extends Map<number, Uint8Array> implements SyncMapStore {
+    readonly label?: string | undefined;
+    readonly flags: readonly [];
+    readonly name = "tmpfs";
+    constructor(label?: string | undefined);
     sync(): Promise<void>;
     clearSync(): void;
-    transaction(): SimpleTransaction;
+    transaction(): SyncMapTransaction;
 }
 declare const _InMemory: {
     readonly name: "InMemory";

package/dist/backends/memory.js

@@ -1,19 +1,21 @@
 import { StoreFS } from './store/fs.js';
-import { SimpleTransaction } from './store/simple.js';
+import { SyncMapTransaction } from './store/map.js';
 /**
  * A simple in-memory store
  */
 export class InMemoryStore extends Map {
-    constructor(name = 'tmp') {
+    constructor(label) {
         super();
-        this.name = name;
+        this.label = label;
+        this.flags = [];
+        this.name = 'tmpfs';
     }
     async sync() { }
     clearSync() {
         this.clear();
     }
     transaction() {
-        return new SimpleTransaction(this);
+        return new SyncMapTransaction(this);
     }
 }
 const _InMemory = {

package/dist/backends/overlay.d.ts

@@ -1,8 +1,8 @@
-import type { File } from '../file.js';
-import type { CreationOptions, FileSystemMetadata } from '../filesystem.js';
+import type { File } from '../internal/file.js';
+import type { CreationOptions } from '../internal/filesystem.js';
 import type { Stats } from '../stats.js';
-import type { InodeLike } from './store/inode.js';
-import { FileSystem } from '../filesystem.js';
+import type { InodeLike } from '../internal/inode.js';
+import { FileSystem } from '../internal/filesystem.js';
 /**
  * Configuration options for OverlayFS instances.
  */
@@ -36,7 +36,6 @@ export declare class OverlayFS extends FileSystem {
     private _deleteLogError?;
     private _ready;
     constructor({ writable, readable }: OverlayOptions);
-    metadata(): FileSystemMetadata;
     sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;

package/dist/backends/overlay.js

@@ -50,10 +50,12 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { Errno, ErrnoError } from '../error.js';
-import { LazyFile, parseFlag } from '../file.js';
-import { FileSystem } from '../filesystem.js';
-import { canary, decodeUTF8, encodeUTF8 } from '../utils.js';
+import { canary } from 'utilium';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { LazyFile, parseFlag } from '../internal/file.js';
+import { FileSystem } from '../internal/filesystem.js';
+import { crit, err, info } from '../internal/log.js';
+import { decodeUTF8, encodeUTF8 } from '../utils.js';
 import { dirname, join } from '../vfs/path.js';
 /** @internal */
 const deletionLogPath = '/.deleted';
@@ -72,7 +74,7 @@ export class OverlayFS extends FileSystem {
         await this._ready;
     }
     constructor({ writable, readable }) {
-        super();
+        super(0x62756c6c, readable.name);
         this._isInitialized = false;
         this._deletedFiles = new Set();
         this._deleteLog = '';
@@ -83,17 +85,11 @@ export class OverlayFS extends FileSystem {
         this._deleteLogUpdateNeeded = false;
         this.writable = writable;
         this.readable = readable;
-        if (this.writable.metadata().readonly) {
-            throw new ErrnoError(Errno.EINVAL, 'Writable file system must be writable.');
+        if (this.writable.attributes.has('no_write')) {
+            throw err(new ErrnoError(Errno.EINVAL, 'Writable file can not be written to'));
         }
         this._ready = this._initialize();
     }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: OverlayFS.name,
-        };
-    }
     async sync(path, data, stats) {
         await this.copyForWrite(path);
         await this.writable.sync(path, data, stats);
@@ -133,10 +129,10 @@ export class OverlayFS extends FileSystem {
             const { buffer } = await file.read(new Uint8Array(size));
             this._deleteLog = decodeUTF8(buffer);
         }
-        catch (err) {
-            if (err.errno !== Errno.ENOENT) {
-                throw err;
-            }
+        catch (error) {
+            if (error.errno !== Errno.ENOENT)
+                throw err(error);
+            info('Overlay does not have a deletion log');
         }
         this._isInitialized = true;
         this._reparseDeletionLog();
@@ -405,7 +401,7 @@ export class OverlayFS extends FileSystem {
     }
     checkInitialized() {
         if (!this._isInitialized) {
-            throw new ErrnoError(Errno.EPERM, 'Overlay is not initialized');
+            throw crit(new ErrnoError(Errno.EPERM, 'Overlay is not initialized'), { fs: this });
         }
         if (!this._deleteLogError) {
             return;
@@ -426,7 +422,7 @@ export class OverlayFS extends FileSystem {
     createParentDirectoriesSync(path) {
         let parent = dirname(path);
         const toCreate = [];
-        const silence = canary(path);
+        const silence = canary(ErrnoError.With('EDEADLK', path));
         while (!this.writable.existsSync(parent)) {
             toCreate.push(parent);
             parent = dirname(parent);
@@ -444,7 +440,7 @@ export class OverlayFS extends FileSystem {
     async createParentDirectories(path) {
         let parent = dirname(path);
         const toCreate = [];
-        const silence = canary(path);
+        const silence = canary(ErrnoError.With('EDEADLK', path));
         while (!(await this.writable.exists(parent))) {
             toCreate.push(parent);
             parent = dirname(parent);

package/dist/backends/passthrough.d.ts

@@ -1,8 +1,8 @@
 import type * as fs from 'node:fs';
-import { File } from '../file.js';
-import { FileSystem } from '../filesystem.js';
+import { File } from '../internal/file.js';
+import { FileSystem } from '../internal/filesystem.js';
+import type { InodeLike } from '../internal/inode.js';
 import { Stats } from '../stats.js';
-import type { InodeLike } from './store/inode.js';
 export type NodeFS = typeof fs;
 export interface PassthroughOptions {
     fs: NodeFS;

package/dist/backends/passthrough.js

@@ -50,9 +50,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { ErrnoError } from '../error.js';
-import { File } from '../file.js';
-import { FileSystem } from '../filesystem.js';
+import { ErrnoError } from '../internal/error.js';
+import { File } from '../internal/file.js';
+import { FileSystem } from '../internal/filesystem.js';
 import { Stats } from '../stats.js';
 import { join, resolve } from '../vfs/path.js';
 class PassthroughFile extends File {
@@ -137,7 +137,7 @@ class PassthroughFile extends File {
 }
 export class PassthroughFS extends FileSystem {
     constructor(nodeFS, prefix) {
-        super();
+        super(0x6e6f6465, 'nodefs');
         this.nodeFS = nodeFS;
         this.prefix = prefix;
     }
@@ -426,8 +426,6 @@ export class PassthroughFS extends FileSystem {
             if (fd)
                 this.nodeFS.closeSync(fd);
         }
-        // unreachable
-        throw ErrnoError.With('EIO', path, 'read');
     }
     async write(path, buffer, offset) {
         try {

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

@@ -1,10 +1,10 @@
 import type { ExtractProperties } from 'utilium';
+import type { Inode, InodeLike } from '../..//internal/inode.js';
 import type { MountConfiguration } from '../../config.js';
-import type { CreationOptions, FileSystemMetadata } from '../../filesystem.js';
+import type { File } from '../../internal/file.js';
+import type { CreationOptions, FileSystemMetadata } from '../../internal/filesystem.js';
 import type { Backend, FilesystemOf } from '../backend.js';
-import type { Inode, InodeLike } from '../store/inode.js';
-import type { File } from '../../file.js';
-import { FileSystem } from '../../filesystem.js';
+import { FileSystem } from '../../internal/filesystem.js';
 import { Stats } from '../../stats.js';
 import * as RPC from './rpc.js';
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
@@ -33,7 +33,6 @@ export declare class PortFS extends PortFS_base {
      * Constructs a new PortFS instance that connects with the FS running on `options.port`.
      */
     constructor(options: RPC.Options);
-    metadata(): FileSystemMetadata;
     protected rpc<const T extends FSMethod>(method: T, ...args: Parameters<FSMethods[T]>): Promise<Awaited<ReturnType<FSMethods[T]>>>;
     ready(): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;